constraint_solver_csharp_wrap.cc

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.2
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */
 
 
#ifndef SWIGCSHARP
#define SWIGCSHARP
#endif
 
#define SWIG_DIRECTORS
 
 
#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};
 
template <typename T> T SwigValueInit() {
  return T();
}
#endif
 
/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */
 
/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif
 
/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif
 
/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif
 
#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif
 
#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif
 
/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif
 
/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif
 
/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif
 
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif
 
/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif
 
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
 
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif
 
/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif
 
/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif
 
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
 
/* Support for throwing C# exceptions from C/C++. There are two types: 
 * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
typedef enum {
  SWIG_CSharpApplicationException,
  SWIG_CSharpArithmeticException,
  SWIG_CSharpDivideByZeroException,
  SWIG_CSharpIndexOutOfRangeException,
  SWIG_CSharpInvalidCastException,
  SWIG_CSharpInvalidOperationException,
  SWIG_CSharpIOException,
  SWIG_CSharpNullReferenceException,
  SWIG_CSharpOutOfMemoryException,
  SWIG_CSharpOverflowException,
  SWIG_CSharpSystemException
} SWIG_CSharpExceptionCodes;
 
typedef enum {
  SWIG_CSharpArgumentException,
  SWIG_CSharpArgumentNullException,
  SWIG_CSharpArgumentOutOfRangeException
} SWIG_CSharpExceptionArgumentCodes;
 
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 
typedef struct {
  SWIG_CSharpExceptionCodes code;
  SWIG_CSharpExceptionCallback_t callback;
} SWIG_CSharpException_t;
 
typedef struct {
  SWIG_CSharpExceptionArgumentCodes code;
  SWIG_CSharpExceptionArgumentCallback_t callback;
} SWIG_CSharpExceptionArgument_t;
 
static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
  { SWIG_CSharpApplicationException, NULL },
  { SWIG_CSharpArithmeticException, NULL },
  { SWIG_CSharpDivideByZeroException, NULL },
  { SWIG_CSharpIndexOutOfRangeException, NULL },
  { SWIG_CSharpInvalidCastException, NULL },
  { SWIG_CSharpInvalidOperationException, NULL },
  { SWIG_CSharpIOException, NULL },
  { SWIG_CSharpNullReferenceException, NULL },
  { SWIG_CSharpOutOfMemoryException, NULL },
  { SWIG_CSharpOverflowException, NULL },
  { SWIG_CSharpSystemException, NULL }
};
 
static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
  { SWIG_CSharpArgumentException, NULL },
  { SWIG_CSharpArgumentNullException, NULL },
  { SWIG_CSharpArgumentOutOfRangeException, NULL }
};
 
static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
    callback = SWIG_csharp_exceptions[code].callback;
  }
  callback(msg);
}
 
static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
    callback = SWIG_csharp_exceptions_argument[code].callback;
  }
  callback(msg, param_name);
}
 
 
#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_operations_research_constraint_solver(
                                                SWIG_CSharpExceptionCallback_t applicationCallback,
                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
                                                SWIG_CSharpExceptionCallback_t invalidCastCallback,
                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
                                                SWIG_CSharpExceptionCallback_t ioCallback,
                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
                                                SWIG_CSharpExceptionCallback_t systemCallback) {
  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
}
 
#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_operations_research_constraint_solver(
                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
}
 
 
/* Callback for returning strings to C# without leaking memory */
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 
 
#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_operations_research_constraint_solver(SWIG_CSharpStringHelperCallback callback) {
  SWIG_csharp_string_callback = callback;
}
 
 
/* Contract support */
 
#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 
/*  Errors in SWIG */
#define  SWIG_UnknownError         -1
#define  SWIG_IOError              -2
#define  SWIG_RuntimeError         -3
#define  SWIG_IndexError           -4
#define  SWIG_TypeError            -5
#define  SWIG_DivisionByZero       -6
#define  SWIG_OverflowError        -7
#define  SWIG_SyntaxError          -8
#define  SWIG_ValueError           -9
#define  SWIG_SystemError          -10
#define  SWIG_AttributeError       -11
#define  SWIG_MemoryError          -12
#define  SWIG_NullReferenceError   -13
 
 
 
/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */
 
/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that C# proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */
 
#if defined(DEBUG_DIRECTOR_OWNED)
#include <iostream>
#endif
#include <string>
#include <exception>
 
namespace Swig {
  /* Director base class - not currently used in C# directors */
  class Director {
  };
 
  /* Base class for director exceptions */
  class DirectorException : public std::exception {
  protected:
    std::string swig_msg;
 
  public:
    DirectorException(const char *msg) : swig_msg(msg) {
    }
 
    DirectorException(const std::string &msg) : swig_msg(msg) {
    }
 
    virtual ~DirectorException() throw() {
    }
 
    const char *what() const throw() {
      return swig_msg.c_str();
    }
  };
 
  /* Pure virtual method exception */
  class DirectorPureVirtualException : public DirectorException {
  public:
    DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
    }
 
    static void raise(const char *msg) {
      throw DirectorPureVirtualException(msg);
    }
  };
}
 
 
#include <typeinfo>
#include <stdexcept>
 
 
SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
  if (code == SWIG_ValueError) {
    SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
    SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
  } else {
    SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
    switch(code) {
    case SWIG_MemoryError:
      exception_code = SWIG_CSharpOutOfMemoryException;
      break;
    case SWIG_IndexError:
      exception_code = SWIG_CSharpIndexOutOfRangeException;
      break;
    case SWIG_DivisionByZero:
      exception_code = SWIG_CSharpDivideByZeroException;
      break;
    case SWIG_IOError:
      exception_code = SWIG_CSharpIOException;
      break;
    case SWIG_OverflowError:
      exception_code = SWIG_CSharpOverflowException;
      break;
    case SWIG_RuntimeError:
    case SWIG_TypeError:
    case SWIG_SyntaxError:
    case SWIG_SystemError:
    case SWIG_UnknownError:
    default:
      exception_code = SWIG_CSharpApplicationException;
      break;
    }
    SWIG_CSharpSetPendingException(exception_code, msg);
  }
}
 
 
#include <typeinfo>
#include <stdexcept>
 
 
#include <utility>
 
 
#include <vector>
#include <algorithm>
#include <stdexcept>
 
 
#include <string>
 
 
#include <cstdint>
#include <string>
#include <vector>
 
#include "ortools/base/basictypes.h"
 
 
#include <stdint.h>     // Use the C99 official header
 
 
#define SWIGWORDSIZE64
#ifndef LONG_MAX
#include <limits.h>
#endif
#if (__WORDSIZE == 32) || (LONG_MAX == INT_MAX)
# error "SWIG wrapped code invalid in 32 bit architecture, regenerate code using -DSWIGWORDSIZE32"
#endif
 
 
#include <vector>
#include "ortools/base/integral_types.h"
 
SWIGINTERN std::vector< int > *new_std_vector_Sl_int_Sg___SWIG_2(int capacity){
        std::vector< int >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< int >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN int std_vector_Sl_int_Sg__getitemcopy(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg__getitem(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__setitem(std::vector< int > *self,int index,int const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__AddRange(std::vector< int > *self,std::vector< int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__GetRange(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< int >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int_Sg__Insert(std::vector< int > *self,int index,int const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__InsertRange(std::vector< int > *self,int index,std::vector< int > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__RemoveAt(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__RemoveRange(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__Repeat(int const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< int >(count, value);
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_0(std::vector< int > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_1(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int_Sg__SetRange(std::vector< int > *self,int index,std::vector< int > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_int_Sg__Contains(std::vector< int > *self,int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int_Sg__IndexOf(std::vector< int > *self,int const &value){
        int index = -1;
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_int_Sg__LastIndexOf(std::vector< int > *self,int const &value){
        int index = -1;
        std::vector< int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_int_Sg__Remove(std::vector< int > *self,int const &value){
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::vector< int > > *new_std_vector_Sl_std_vector_Sl_int_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< int > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< int > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< int > std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitemcopy(std::vector< std::vector< int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::vector< int > >::value_type const &std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitem(std::vector< std::vector< int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__setitem(std::vector< std::vector< int > > *self,int index,std::vector< int > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__AddRange(std::vector< std::vector< int > > *self,std::vector< std::vector< int > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< int > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg__GetRange(std::vector< std::vector< int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< int > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Insert(std::vector< std::vector< int > > *self,int index,std::vector< int > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__InsertRange(std::vector< std::vector< int > > *self,int index,std::vector< std::vector< int > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveAt(std::vector< std::vector< int > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveRange(std::vector< std::vector< int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< int > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg__Repeat(std::vector< int > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< int > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< int > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< int > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__SetRange(std::vector< std::vector< int > > *self,int index,std::vector< std::vector< int > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN std::vector< int64_t > *new_std_vector_Sl_int64_t_Sg___SWIG_2(int capacity){
        std::vector< long >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< long >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN long std_vector_Sl_int64_t_Sg__getitemcopy(std::vector< int64_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< long >::value_type const &std_vector_Sl_int64_t_Sg__getitem(std::vector< int64_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__setitem(std::vector< int64_t > *self,int index,long const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__AddRange(std::vector< int64_t > *self,std::vector< long > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< long > *std_vector_Sl_int64_t_Sg__GetRange(std::vector< int64_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< long >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__Insert(std::vector< int64_t > *self,int index,long const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__InsertRange(std::vector< int64_t > *self,int index,std::vector< long > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__RemoveAt(std::vector< int64_t > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__RemoveRange(std::vector< int64_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< long > *std_vector_Sl_int64_t_Sg__Repeat(long const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< long >(count, value);
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__Reverse__SWIG_0(std::vector< int64_t > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__Reverse__SWIG_1(std::vector< int64_t > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int64_t_Sg__SetRange(std::vector< int64_t > *self,int index,std::vector< long > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_int64_t_Sg__Contains(std::vector< int64_t > *self,long const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int64_t_Sg__IndexOf(std::vector< int64_t > *self,long const &value){
        int index = -1;
        std::vector< long >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_int64_t_Sg__LastIndexOf(std::vector< int64_t > *self,long const &value){
        int index = -1;
        std::vector< long >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_int64_t_Sg__Remove(std::vector< int64_t > *self,long const &value){
        std::vector< long >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::vector< int64_t > > *new_std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg___SWIG_2(int capacity){
        std::vector< std::vector< int64_t > >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::vector< int64_t > >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::vector< int64_t > std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitemcopy(std::vector< std::vector< int64_t > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::vector< long > >::value_type const &std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitem(std::vector< std::vector< int64_t > > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__setitem(std::vector< std::vector< int64_t > > *self,int index,std::vector< int64_t > const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__AddRange(std::vector< std::vector< int64_t > > *self,std::vector< std::vector< int64_t > > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::vector< int64_t > > *std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__GetRange(std::vector< std::vector< int64_t > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::vector< int64_t > >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Insert(std::vector< std::vector< int64_t > > *self,int index,std::vector< int64_t > const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__InsertRange(std::vector< std::vector< int64_t > > *self,int index,std::vector< std::vector< int64_t > > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveAt(std::vector< std::vector< int64_t > > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveRange(std::vector< std::vector< int64_t > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::vector< int64_t > > *std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Repeat(std::vector< int64_t > const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::vector< int64_t > >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_0(std::vector< std::vector< int64_t > > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_1(std::vector< std::vector< int64_t > > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__SetRange(std::vector< std::vector< int64_t > > *self,int index,std::vector< std::vector< int64_t > > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
 
#include <vector>
#include "ortools/base/integral_types.h"
 
 
#include <setjmp.h>
 
#include <string>
#include <vector>
#include <functional>
 
#include "ortools/base/integral_types.h"
#include "ortools/constraint_solver/constraint_solver.h"
#include "ortools/constraint_solver/constraint_solveri.h"
#include "ortools/constraint_solver/search_limit.pb.h"
#include "ortools/constraint_solver/solver_parameters.pb.h"
 
namespace operations_research {
class LocalSearchPhaseParameters {
 public:
  LocalSearchPhaseParameters() {}
  ~LocalSearchPhaseParameters() {}
};
}  // namespace operations_research
 
struct FailureProtect {
  jmp_buf exception_buffer;
  void JumpBack() {
    longjmp(exception_buffer, 1);
  }
};
 
 
#include "ortools/util/tuple_set.h"
 
SWIGINTERN std::vector< operations_research::IntVar * > *new_std_vector_Sl_operations_research_IntVar_Sm__Sg___SWIG_2(int capacity){
        std::vector< operations_research::IntVar* >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< operations_research::IntVar* >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN operations_research::IntVar *std_vector_Sl_operations_research_IntVar_Sm__Sg__getitemcopy(std::vector< operations_research::IntVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< operations_research::IntVar * >::value_type const &std_vector_Sl_operations_research_IntVar_Sm__Sg__getitem(std::vector< operations_research::IntVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__setitem(std::vector< operations_research::IntVar * > *self,int index,operations_research::IntVar *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__AddRange(std::vector< operations_research::IntVar * > *self,std::vector< operations_research::IntVar * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< operations_research::IntVar * > *std_vector_Sl_operations_research_IntVar_Sm__Sg__GetRange(std::vector< operations_research::IntVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< operations_research::IntVar* >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__Insert(std::vector< operations_research::IntVar * > *self,int index,operations_research::IntVar *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__InsertRange(std::vector< operations_research::IntVar * > *self,int index,std::vector< operations_research::IntVar * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__RemoveAt(std::vector< operations_research::IntVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__RemoveRange(std::vector< operations_research::IntVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< operations_research::IntVar * > *std_vector_Sl_operations_research_IntVar_Sm__Sg__Repeat(operations_research::IntVar *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< operations_research::IntVar* >(count, value);
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::IntVar * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::IntVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_IntVar_Sm__Sg__SetRange(std::vector< operations_research::IntVar * > *self,int index,std::vector< operations_research::IntVar * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_operations_research_IntVar_Sm__Sg__Contains(std::vector< operations_research::IntVar * > *self,operations_research::IntVar *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_operations_research_IntVar_Sm__Sg__IndexOf(std::vector< operations_research::IntVar * > *self,operations_research::IntVar *const &value){
        int index = -1;
        std::vector< operations_research::IntVar* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_operations_research_IntVar_Sm__Sg__LastIndexOf(std::vector< operations_research::IntVar * > *self,operations_research::IntVar *const &value){
        int index = -1;
        std::vector< operations_research::IntVar* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_operations_research_IntVar_Sm__Sg__Remove(std::vector< operations_research::IntVar * > *self,operations_research::IntVar *const &value){
        std::vector< operations_research::IntVar* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< operations_research::SearchMonitor * > *new_std_vector_Sl_operations_research_SearchMonitor_Sm__Sg___SWIG_2(int capacity){
        std::vector< operations_research::SearchMonitor* >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< operations_research::SearchMonitor* >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN operations_research::SearchMonitor *std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__getitemcopy(std::vector< operations_research::SearchMonitor * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< operations_research::SearchMonitor * >::value_type const &std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__getitem(std::vector< operations_research::SearchMonitor * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__setitem(std::vector< operations_research::SearchMonitor * > *self,int index,operations_research::SearchMonitor *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__AddRange(std::vector< operations_research::SearchMonitor * > *self,std::vector< operations_research::SearchMonitor * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< operations_research::SearchMonitor * > *std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__GetRange(std::vector< operations_research::SearchMonitor * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< operations_research::SearchMonitor* >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Insert(std::vector< operations_research::SearchMonitor * > *self,int index,operations_research::SearchMonitor *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__InsertRange(std::vector< operations_research::SearchMonitor * > *self,int index,std::vector< operations_research::SearchMonitor * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__RemoveAt(std::vector< operations_research::SearchMonitor * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__RemoveRange(std::vector< operations_research::SearchMonitor * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< operations_research::SearchMonitor * > *std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Repeat(operations_research::SearchMonitor *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< operations_research::SearchMonitor* >(count, value);
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::SearchMonitor * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::SearchMonitor * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__SetRange(std::vector< operations_research::SearchMonitor * > *self,int index,std::vector< operations_research::SearchMonitor * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Contains(std::vector< operations_research::SearchMonitor * > *self,operations_research::SearchMonitor *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__IndexOf(std::vector< operations_research::SearchMonitor * > *self,operations_research::SearchMonitor *const &value){
        int index = -1;
        std::vector< operations_research::SearchMonitor* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__LastIndexOf(std::vector< operations_research::SearchMonitor * > *self,operations_research::SearchMonitor *const &value){
        int index = -1;
        std::vector< operations_research::SearchMonitor* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Remove(std::vector< operations_research::SearchMonitor * > *self,operations_research::SearchMonitor *const &value){
        std::vector< operations_research::SearchMonitor* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< operations_research::DecisionBuilder * > *new_std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg___SWIG_2(int capacity){
        std::vector< operations_research::DecisionBuilder* >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< operations_research::DecisionBuilder* >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN operations_research::DecisionBuilder *std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__getitemcopy(std::vector< operations_research::DecisionBuilder * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< operations_research::DecisionBuilder * >::value_type const &std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__getitem(std::vector< operations_research::DecisionBuilder * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__setitem(std::vector< operations_research::DecisionBuilder * > *self,int index,operations_research::DecisionBuilder *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__AddRange(std::vector< operations_research::DecisionBuilder * > *self,std::vector< operations_research::DecisionBuilder * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< operations_research::DecisionBuilder * > *std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__GetRange(std::vector< operations_research::DecisionBuilder * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< operations_research::DecisionBuilder* >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Insert(std::vector< operations_research::DecisionBuilder * > *self,int index,operations_research::DecisionBuilder *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__InsertRange(std::vector< operations_research::DecisionBuilder * > *self,int index,std::vector< operations_research::DecisionBuilder * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__RemoveAt(std::vector< operations_research::DecisionBuilder * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__RemoveRange(std::vector< operations_research::DecisionBuilder * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< operations_research::DecisionBuilder * > *std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Repeat(operations_research::DecisionBuilder *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< operations_research::DecisionBuilder* >(count, value);
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::DecisionBuilder * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::DecisionBuilder * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__SetRange(std::vector< operations_research::DecisionBuilder * > *self,int index,std::vector< operations_research::DecisionBuilder * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Contains(std::vector< operations_research::DecisionBuilder * > *self,operations_research::DecisionBuilder *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__IndexOf(std::vector< operations_research::DecisionBuilder * > *self,operations_research::DecisionBuilder *const &value){
        int index = -1;
        std::vector< operations_research::DecisionBuilder* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__LastIndexOf(std::vector< operations_research::DecisionBuilder * > *self,operations_research::DecisionBuilder *const &value){
        int index = -1;
        std::vector< operations_research::DecisionBuilder* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Remove(std::vector< operations_research::DecisionBuilder * > *self,operations_research::DecisionBuilder *const &value){
        std::vector< operations_research::DecisionBuilder* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< operations_research::IntervalVar * > *new_std_vector_Sl_operations_research_IntervalVar_Sm__Sg___SWIG_2(int capacity){
        std::vector< operations_research::IntervalVar* >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< operations_research::IntervalVar* >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN operations_research::IntervalVar *std_vector_Sl_operations_research_IntervalVar_Sm__Sg__getitemcopy(std::vector< operations_research::IntervalVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< operations_research::IntervalVar * >::value_type const &std_vector_Sl_operations_research_IntervalVar_Sm__Sg__getitem(std::vector< operations_research::IntervalVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__setitem(std::vector< operations_research::IntervalVar * > *self,int index,operations_research::IntervalVar *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__AddRange(std::vector< operations_research::IntervalVar * > *self,std::vector< operations_research::IntervalVar * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< operations_research::IntervalVar * > *std_vector_Sl_operations_research_IntervalVar_Sm__Sg__GetRange(std::vector< operations_research::IntervalVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< operations_research::IntervalVar* >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Insert(std::vector< operations_research::IntervalVar * > *self,int index,operations_research::IntervalVar *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__InsertRange(std::vector< operations_research::IntervalVar * > *self,int index,std::vector< operations_research::IntervalVar * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__RemoveAt(std::vector< operations_research::IntervalVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__RemoveRange(std::vector< operations_research::IntervalVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< operations_research::IntervalVar * > *std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Repeat(operations_research::IntervalVar *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< operations_research::IntervalVar* >(count, value);
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::IntervalVar * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::IntervalVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_IntervalVar_Sm__Sg__SetRange(std::vector< operations_research::IntervalVar * > *self,int index,std::vector< operations_research::IntervalVar * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Contains(std::vector< operations_research::IntervalVar * > *self,operations_research::IntervalVar *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_operations_research_IntervalVar_Sm__Sg__IndexOf(std::vector< operations_research::IntervalVar * > *self,operations_research::IntervalVar *const &value){
        int index = -1;
        std::vector< operations_research::IntervalVar* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_operations_research_IntervalVar_Sm__Sg__LastIndexOf(std::vector< operations_research::IntervalVar * > *self,operations_research::IntervalVar *const &value){
        int index = -1;
        std::vector< operations_research::IntervalVar* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Remove(std::vector< operations_research::IntervalVar * > *self,operations_research::IntervalVar *const &value){
        std::vector< operations_research::IntervalVar* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< operations_research::SequenceVar * > *new_std_vector_Sl_operations_research_SequenceVar_Sm__Sg___SWIG_2(int capacity){
        std::vector< operations_research::SequenceVar* >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< operations_research::SequenceVar* >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN operations_research::SequenceVar *std_vector_Sl_operations_research_SequenceVar_Sm__Sg__getitemcopy(std::vector< operations_research::SequenceVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< operations_research::SequenceVar * >::value_type const &std_vector_Sl_operations_research_SequenceVar_Sm__Sg__getitem(std::vector< operations_research::SequenceVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__setitem(std::vector< operations_research::SequenceVar * > *self,int index,operations_research::SequenceVar *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__AddRange(std::vector< operations_research::SequenceVar * > *self,std::vector< operations_research::SequenceVar * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< operations_research::SequenceVar * > *std_vector_Sl_operations_research_SequenceVar_Sm__Sg__GetRange(std::vector< operations_research::SequenceVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< operations_research::SequenceVar* >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Insert(std::vector< operations_research::SequenceVar * > *self,int index,operations_research::SequenceVar *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__InsertRange(std::vector< operations_research::SequenceVar * > *self,int index,std::vector< operations_research::SequenceVar * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__RemoveAt(std::vector< operations_research::SequenceVar * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__RemoveRange(std::vector< operations_research::SequenceVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< operations_research::SequenceVar * > *std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Repeat(operations_research::SequenceVar *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< operations_research::SequenceVar* >(count, value);
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::SequenceVar * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::SequenceVar * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_SequenceVar_Sm__Sg__SetRange(std::vector< operations_research::SequenceVar * > *self,int index,std::vector< operations_research::SequenceVar * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Contains(std::vector< operations_research::SequenceVar * > *self,operations_research::SequenceVar *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_operations_research_SequenceVar_Sm__Sg__IndexOf(std::vector< operations_research::SequenceVar * > *self,operations_research::SequenceVar *const &value){
        int index = -1;
        std::vector< operations_research::SequenceVar* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_operations_research_SequenceVar_Sm__Sg__LastIndexOf(std::vector< operations_research::SequenceVar * > *self,operations_research::SequenceVar *const &value){
        int index = -1;
        std::vector< operations_research::SequenceVar* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Remove(std::vector< operations_research::SequenceVar * > *self,operations_research::SequenceVar *const &value){
        std::vector< operations_research::SequenceVar* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< operations_research::LocalSearchOperator * > *new_std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg___SWIG_2(int capacity){
        std::vector< operations_research::LocalSearchOperator* >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< operations_research::LocalSearchOperator* >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN operations_research::LocalSearchOperator *std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__getitemcopy(std::vector< operations_research::LocalSearchOperator * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< operations_research::LocalSearchOperator * >::value_type const &std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__getitem(std::vector< operations_research::LocalSearchOperator * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__setitem(std::vector< operations_research::LocalSearchOperator * > *self,int index,operations_research::LocalSearchOperator *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__AddRange(std::vector< operations_research::LocalSearchOperator * > *self,std::vector< operations_research::LocalSearchOperator * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< operations_research::LocalSearchOperator * > *std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__GetRange(std::vector< operations_research::LocalSearchOperator * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< operations_research::LocalSearchOperator* >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Insert(std::vector< operations_research::LocalSearchOperator * > *self,int index,operations_research::LocalSearchOperator *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__InsertRange(std::vector< operations_research::LocalSearchOperator * > *self,int index,std::vector< operations_research::LocalSearchOperator * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__RemoveAt(std::vector< operations_research::LocalSearchOperator * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__RemoveRange(std::vector< operations_research::LocalSearchOperator * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< operations_research::LocalSearchOperator * > *std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Repeat(operations_research::LocalSearchOperator *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< operations_research::LocalSearchOperator* >(count, value);
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::LocalSearchOperator * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::LocalSearchOperator * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__SetRange(std::vector< operations_research::LocalSearchOperator * > *self,int index,std::vector< operations_research::LocalSearchOperator * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Contains(std::vector< operations_research::LocalSearchOperator * > *self,operations_research::LocalSearchOperator *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__IndexOf(std::vector< operations_research::LocalSearchOperator * > *self,operations_research::LocalSearchOperator *const &value){
        int index = -1;
        std::vector< operations_research::LocalSearchOperator* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__LastIndexOf(std::vector< operations_research::LocalSearchOperator * > *self,operations_research::LocalSearchOperator *const &value){
        int index = -1;
        std::vector< operations_research::LocalSearchOperator* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Remove(std::vector< operations_research::LocalSearchOperator * > *self,operations_research::LocalSearchOperator *const &value){
        std::vector< operations_research::LocalSearchOperator* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< operations_research::LocalSearchFilter * > *new_std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg___SWIG_2(int capacity){
        std::vector< operations_research::LocalSearchFilter* >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< operations_research::LocalSearchFilter* >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN operations_research::LocalSearchFilter *std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__getitemcopy(std::vector< operations_research::LocalSearchFilter * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< operations_research::LocalSearchFilter * >::value_type const &std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__getitem(std::vector< operations_research::LocalSearchFilter * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__setitem(std::vector< operations_research::LocalSearchFilter * > *self,int index,operations_research::LocalSearchFilter *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__AddRange(std::vector< operations_research::LocalSearchFilter * > *self,std::vector< operations_research::LocalSearchFilter * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< operations_research::LocalSearchFilter * > *std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__GetRange(std::vector< operations_research::LocalSearchFilter * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< operations_research::LocalSearchFilter* >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Insert(std::vector< operations_research::LocalSearchFilter * > *self,int index,operations_research::LocalSearchFilter *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__InsertRange(std::vector< operations_research::LocalSearchFilter * > *self,int index,std::vector< operations_research::LocalSearchFilter * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__RemoveAt(std::vector< operations_research::LocalSearchFilter * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__RemoveRange(std::vector< operations_research::LocalSearchFilter * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< operations_research::LocalSearchFilter * > *std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Repeat(operations_research::LocalSearchFilter *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< operations_research::LocalSearchFilter* >(count, value);
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::LocalSearchFilter * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::LocalSearchFilter * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__SetRange(std::vector< operations_research::LocalSearchFilter * > *self,int index,std::vector< operations_research::LocalSearchFilter * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Contains(std::vector< operations_research::LocalSearchFilter * > *self,operations_research::LocalSearchFilter *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__IndexOf(std::vector< operations_research::LocalSearchFilter * > *self,operations_research::LocalSearchFilter *const &value){
        int index = -1;
        std::vector< operations_research::LocalSearchFilter* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__LastIndexOf(std::vector< operations_research::LocalSearchFilter * > *self,operations_research::LocalSearchFilter *const &value){
        int index = -1;
        std::vector< operations_research::LocalSearchFilter* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Remove(std::vector< operations_research::LocalSearchFilter * > *self,operations_research::LocalSearchFilter *const &value){
        std::vector< operations_research::LocalSearchFilter* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN std::vector< operations_research::SymmetryBreaker * > *new_std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg___SWIG_2(int capacity){
        std::vector< operations_research::SymmetryBreaker* >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< operations_research::SymmetryBreaker* >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN operations_research::SymmetryBreaker *std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__getitemcopy(std::vector< operations_research::SymmetryBreaker * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< operations_research::SymmetryBreaker * >::value_type const &std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__getitem(std::vector< operations_research::SymmetryBreaker * > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__setitem(std::vector< operations_research::SymmetryBreaker * > *self,int index,operations_research::SymmetryBreaker *const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__AddRange(std::vector< operations_research::SymmetryBreaker * > *self,std::vector< operations_research::SymmetryBreaker * > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< operations_research::SymmetryBreaker * > *std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__GetRange(std::vector< operations_research::SymmetryBreaker * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< operations_research::SymmetryBreaker* >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Insert(std::vector< operations_research::SymmetryBreaker * > *self,int index,operations_research::SymmetryBreaker *const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__InsertRange(std::vector< operations_research::SymmetryBreaker * > *self,int index,std::vector< operations_research::SymmetryBreaker * > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__RemoveAt(std::vector< operations_research::SymmetryBreaker * > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__RemoveRange(std::vector< operations_research::SymmetryBreaker * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< operations_research::SymmetryBreaker * > *std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Repeat(operations_research::SymmetryBreaker *const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< operations_research::SymmetryBreaker* >(count, value);
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Reverse__SWIG_0(std::vector< operations_research::SymmetryBreaker * > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Reverse__SWIG_1(std::vector< operations_research::SymmetryBreaker * > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__SetRange(std::vector< operations_research::SymmetryBreaker * > *self,int index,std::vector< operations_research::SymmetryBreaker * > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Contains(std::vector< operations_research::SymmetryBreaker * > *self,operations_research::SymmetryBreaker *const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__IndexOf(std::vector< operations_research::SymmetryBreaker * > *self,operations_research::SymmetryBreaker *const &value){
        int index = -1;
        std::vector< operations_research::SymmetryBreaker* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__LastIndexOf(std::vector< operations_research::SymmetryBreaker * > *self,operations_research::SymmetryBreaker *const &value){
        int index = -1;
        std::vector< operations_research::SymmetryBreaker* >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Remove(std::vector< operations_research::SymmetryBreaker * > *self,operations_research::SymmetryBreaker *const &value){
        std::vector< operations_research::SymmetryBreaker* >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
          return true;
        }
        return false;
      }
SWIGINTERN operations_research::Constraint *operations_research_IntExpr_MapTo(operations_research::IntExpr *self,std::vector< operations_research::IntVar * > const &vars){
    return self->solver()->MakeMapDomain(self->Var(), vars);
  }
SWIGINTERN operations_research::IntExpr *operations_research_IntExpr_IndexOf__SWIG_0(operations_research::IntExpr *self,std::vector< int64_t > const &vars){
    return self->solver()->MakeElement(vars, self->Var());
  }
SWIGINTERN operations_research::IntExpr *operations_research_IntExpr_IndexOf__SWIG_1(operations_research::IntExpr *self,std::vector< operations_research::IntVar * > const &vars){
    return self->solver()->MakeElement(vars, self->Var());
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsEqual__SWIG_0(operations_research::IntExpr *self,int64_t value){
    return self->solver()->MakeIsEqualCstVar(self->Var(), value);
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsDifferent__SWIG_0(operations_research::IntExpr *self,int64_t value){
    return self->solver()->MakeIsDifferentCstVar(self->Var(), value);
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsGreater__SWIG_0(operations_research::IntExpr *self,int64_t value){
    return self->solver()->MakeIsGreaterCstVar(self->Var(), value);
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsGreaterOrEqual__SWIG_0(operations_research::IntExpr *self,int64_t value){
    return self->solver()->MakeIsGreaterOrEqualCstVar(self->Var(), value);
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsLess__SWIG_0(operations_research::IntExpr *self,int64_t value){
    return self->solver()->MakeIsLessCstVar(self->Var(), value);
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsLessOrEqual__SWIG_0(operations_research::IntExpr *self,int64_t value){
    return self->solver()->MakeIsLessOrEqualCstVar(self->Var(), value);
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsMember__SWIG_0(operations_research::IntExpr *self,std::vector< int64_t > const &values){
    return self->solver()->MakeIsMemberVar(self->Var(), values);
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsMember__SWIG_1(operations_research::IntExpr *self,std::vector< int > const &values){
    return self->solver()->MakeIsMemberVar(self->Var(), values);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntExpr_Member__SWIG_0(operations_research::IntExpr *self,std::vector< int64_t > const &values){
    return self->solver()->MakeMemberCt(self->Var(), values);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntExpr_Member__SWIG_1(operations_research::IntExpr *self,std::vector< int > const &values){
    return self->solver()->MakeMemberCt(self->Var(), values);
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsEqual__SWIG_1(operations_research::IntExpr *self,operations_research::IntExpr *const other){
    return self->solver()->MakeIsEqualVar(self->Var(), other->Var());
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsDifferent__SWIG_1(operations_research::IntExpr *self,operations_research::IntExpr *const other){
    return self->solver()->MakeIsDifferentVar(self->Var(), other->Var());
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsGreater__SWIG_1(operations_research::IntExpr *self,operations_research::IntExpr *const other){
    return self->solver()->MakeIsGreaterVar(self->Var(), other->Var());
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsGreaterOrEqual__SWIG_1(operations_research::IntExpr *self,operations_research::IntExpr *const other){
    return self->solver()->MakeIsGreaterOrEqualVar(self->Var(), other->Var());
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsLess__SWIG_1(operations_research::IntExpr *self,operations_research::IntExpr *const other){
    return self->solver()->MakeIsLessVar(self->Var(), other->Var());
  }
SWIGINTERN operations_research::IntVar *operations_research_IntExpr_IsLessOrEqual__SWIG_1(operations_research::IntExpr *self,operations_research::IntExpr *const other){
    return self->solver()->MakeIsLessOrEqualVar(self->Var(), other->Var());
  }
SWIGINTERN operations_research::OptimizeVar *operations_research_IntExpr_Minimize(operations_research::IntExpr *self,int64_t step){
    return self->solver()->MakeMinimize(self->Var(), step);
  }
SWIGINTERN operations_research::OptimizeVar *operations_research_IntExpr_Maximize(operations_research::IntExpr *self,int64_t step){
    return self->solver()->MakeMaximize(self->Var(), step);
  }
SWIGINTERN operations_research::IntVarIterator *operations_research_IntVar_GetDomain(operations_research::IntVar *self){
    return self->MakeDomainIterator(false);
  }
SWIGINTERN operations_research::IntVarIterator *operations_research_IntVar_GetHoles(operations_research::IntVar *self){
    return self->MakeHoleIterator(false);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAfterEnd(operations_research::IntervalVar *self,operations_research::IntervalVar *other){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::ENDS_AFTER_END, other);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAfterStart(operations_research::IntervalVar *self,operations_research::IntervalVar *other){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::ENDS_AFTER_START, other);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAtEnd(operations_research::IntervalVar *self,operations_research::IntervalVar *other){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::ENDS_AT_END, other);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAtStart(operations_research::IntervalVar *self,operations_research::IntervalVar *other){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::ENDS_AT_START, other);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAfterEnd(operations_research::IntervalVar *self,operations_research::IntervalVar *other){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::STARTS_AFTER_END, other);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAfterStart(operations_research::IntervalVar *self,operations_research::IntervalVar *other){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::STARTS_AFTER_START, other);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAtEnd(operations_research::IntervalVar *self,operations_research::IntervalVar *other){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::STARTS_AT_END, other);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAtStart(operations_research::IntervalVar *self,operations_research::IntervalVar *other){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::STARTS_AT_START, other);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAfterEndWithDelay(operations_research::IntervalVar *self,operations_research::IntervalVar *other,int64_t delay){
    return self->solver()->MakeIntervalVarRelationWithDelay(self, operations_research::Solver::ENDS_AFTER_END, other, delay);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAfterStartWithDelay(operations_research::IntervalVar *self,operations_research::IntervalVar *other,int64_t delay){
    return self->solver()->MakeIntervalVarRelationWithDelay(self, operations_research::Solver::ENDS_AFTER_START, other, delay);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAtEndWithDelay(operations_research::IntervalVar *self,operations_research::IntervalVar *other,int64_t delay){
    return self->solver()->MakeIntervalVarRelationWithDelay(self, operations_research::Solver::ENDS_AT_END, other, delay);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAtStartWithDelay(operations_research::IntervalVar *self,operations_research::IntervalVar *other,int64_t delay){
    return self->solver()->MakeIntervalVarRelationWithDelay(self, operations_research::Solver::ENDS_AT_START, other, delay);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAfterEndWithDelay(operations_research::IntervalVar *self,operations_research::IntervalVar *other,int64_t delay){
    return self->solver()->MakeIntervalVarRelationWithDelay(self, operations_research::Solver::STARTS_AFTER_END, other, delay);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAfterStartWithDelay(operations_research::IntervalVar *self,operations_research::IntervalVar *other,int64_t delay){
    return self->solver()->MakeIntervalVarRelationWithDelay(self, operations_research::Solver::STARTS_AFTER_START, other, delay);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAtEndWithDelay(operations_research::IntervalVar *self,operations_research::IntervalVar *other,int64_t delay){
    return self->solver()->MakeIntervalVarRelationWithDelay(self, operations_research::Solver::STARTS_AT_END, other, delay);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAtStartWithDelay(operations_research::IntervalVar *self,operations_research::IntervalVar *other,int64_t delay){
    return self->solver()->MakeIntervalVarRelationWithDelay(self, operations_research::Solver::STARTS_AT_START, other, delay);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAfter(operations_research::IntervalVar *self,int64_t date){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::ENDS_AFTER, date);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsAt(operations_research::IntervalVar *self,int64_t date){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::ENDS_AT, date);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_EndsBefore(operations_research::IntervalVar *self,int64_t date){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::ENDS_BEFORE, date);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAfter(operations_research::IntervalVar *self,int64_t date){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::STARTS_AFTER, date);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsAt(operations_research::IntervalVar *self,int64_t date){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::STARTS_AT, date);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_StartsBefore(operations_research::IntervalVar *self,int64_t date){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::STARTS_BEFORE, date);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_CrossesDate(operations_research::IntervalVar *self,int64_t date){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::CROSS_DATE, date);
  }
SWIGINTERN operations_research::Constraint *operations_research_IntervalVar_AvoidsDate(operations_research::IntervalVar *self,int64_t date){
    return self->solver()->MakeIntervalVarRelation(self, operations_research::Solver::AVOID_DATE, date);
  }
SWIGINTERN operations_research::IntervalVar *operations_research_IntervalVar_RelaxedMax(operations_research::IntervalVar *self){
    return self->solver()->MakeIntervalRelaxedMax(self);
  }
SWIGINTERN operations_research::IntervalVar *operations_research_IntervalVar_RelaxedMin(operations_research::IntervalVar *self){
    return self->solver()->MakeIntervalRelaxedMin(self);
  }
SWIGINTERN int operations_research_IntVarLocalSearchFilter_Index(operations_research::IntVarLocalSearchFilter *self,operations_research::IntVar *const var){
    int64_t index = -1;
    self->FindIndex(var, &index);
    return index;
  }
 
#include "ortools/constraint_solver/routing_types.h"
 
 
#include "ortools/constraint_solver/routing_index_manager.h"
 
 
#include "ortools/constraint_solver/routing.h"
#include "ortools/constraint_solver/routing_index_manager.h"
#include "ortools/constraint_solver/routing_parameters.h"
#include "ortools/constraint_solver/routing_parameters.pb.h"
#include "ortools/constraint_solver/routing_types.h"
 
 
 
/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */
 
#include "constraint_solver_csharp_wrap.h"
 
SwigDirector_Decision::SwigDirector_Decision() : operations_research::Decision(), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_Decision::~SwigDirector_Decision() {
  
}
 
 
std::string SwigDirector_Decision::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::Decision::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_Decision::Apply(operations_research::Solver *const s) {
  void * js = 0 ;
  
  if (!swig_callbackApplyWrapper) {
    Swig::DirectorPureVirtualException::raise("operations_research::Decision::Apply");
    return;
  } else {
    js = (void *) s; 
    swig_callbackApplyWrapper(js);
  }
}
 
void SwigDirector_Decision::Refute(operations_research::Solver *const s) {
  void * js = 0 ;
  
  if (!swig_callbackRefuteWrapper) {
    Swig::DirectorPureVirtualException::raise("operations_research::Decision::Refute");
    return;
  } else {
    js = (void *) s; 
    swig_callbackRefuteWrapper(js);
  }
}
 
void SwigDirector_Decision::Accept(operations_research::DecisionVisitor *const visitor) const {
  void * jvisitor = 0 ;
  
  if (!swig_callbackAccept) {
    operations_research::Decision::Accept(visitor);
    return;
  } else {
    jvisitor = (void *) visitor; 
    swig_callbackAccept(jvisitor);
  }
}
 
void SwigDirector_Decision::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackApplyWrapper, SWIG_Callback2_t callbackRefuteWrapper, SWIG_Callback3_t callbackAccept) {
  swig_callbackToString = callbackToString;
  swig_callbackApplyWrapper = callbackApplyWrapper;
  swig_callbackRefuteWrapper = callbackRefuteWrapper;
  swig_callbackAccept = callbackAccept;
}
 
void SwigDirector_Decision::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackApplyWrapper = 0;
  swig_callbackRefuteWrapper = 0;
  swig_callbackAccept = 0;
}
 
SwigDirector_DecisionBuilder::SwigDirector_DecisionBuilder() : operations_research::DecisionBuilder(), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_DecisionBuilder::~SwigDirector_DecisionBuilder() {
  
}
 
 
std::string SwigDirector_DecisionBuilder::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::DecisionBuilder::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
operations_research::Decision *SwigDirector_DecisionBuilder::Next(operations_research::Solver *const s) {
  operations_research::Decision *c_result = 0 ;
  void * jresult = 0 ;
  void * js = 0 ;
  
  if (!swig_callbackNextWrapper) {
    Swig::DirectorPureVirtualException::raise("operations_research::DecisionBuilder::Next");
    return c_result;
  } else {
    js = (void *) s; 
    jresult = (void *) swig_callbackNextWrapper(js);
    c_result = (operations_research::Decision *)jresult; 
  }
  return c_result;
}
 
void SwigDirector_DecisionBuilder::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackNextWrapper) {
  swig_callbackToString = callbackToString;
  swig_callbackNextWrapper = callbackNextWrapper;
}
 
void SwigDirector_DecisionBuilder::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackNextWrapper = 0;
}
 
SwigDirector_Demon::SwigDirector_Demon() : operations_research::Demon(), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_Demon::~SwigDirector_Demon() {
  
}
 
 
std::string SwigDirector_Demon::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::Demon::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_Demon::Run(operations_research::Solver *const s) {
  void * js = 0 ;
  
  if (!swig_callbackRunWrapper) {
    Swig::DirectorPureVirtualException::raise("operations_research::Demon::Run");
    return;
  } else {
    js = (void *) s; 
    swig_callbackRunWrapper(js);
  }
}
 
operations_research::Solver::DemonPriority SwigDirector_Demon::priority() const {
  operations_research::Solver::DemonPriority c_result = SwigValueInit< operations_research::Solver::DemonPriority >() ;
  int jresult = 0 ;
  
  if (!swig_callbackPriority) {
    return operations_research::Demon::priority();
  } else {
    jresult = (int) swig_callbackPriority();
    c_result = (operations_research::Solver::DemonPriority)jresult; 
  }
  return c_result;
}
 
void SwigDirector_Demon::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackRunWrapper, SWIG_Callback2_t callbackPriority) {
  swig_callbackToString = callbackToString;
  swig_callbackRunWrapper = callbackRunWrapper;
  swig_callbackPriority = callbackPriority;
}
 
void SwigDirector_Demon::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackRunWrapper = 0;
  swig_callbackPriority = 0;
}
 
SwigDirector_Constraint::SwigDirector_Constraint(operations_research::Solver *const solver) : operations_research::Constraint(solver), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_Constraint::~SwigDirector_Constraint() {
  
}
 
 
std::string SwigDirector_Constraint::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::Constraint::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
std::string SwigDirector_Constraint::name() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackName) {
    return operations_research::PropagationBaseObject::name();
  } else {
    jresult = (char *) swig_callbackName();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
std::string SwigDirector_Constraint::BaseName() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackBaseName) {
    return operations_research::PropagationBaseObject::BaseName();
  } else {
    jresult = (char *) swig_callbackBaseName();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_Constraint::Post() {
  if (!swig_callbackPost) {
    Swig::DirectorPureVirtualException::raise("operations_research::Constraint::Post");
    return;
  } else {
    swig_callbackPost();
  }
}
 
void SwigDirector_Constraint::InitialPropagate() {
  if (!swig_callbackInitialPropagateWrapper) {
    Swig::DirectorPureVirtualException::raise("operations_research::Constraint::InitialPropagate");
    return;
  } else {
    swig_callbackInitialPropagateWrapper();
  }
}
 
void SwigDirector_Constraint::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackName, SWIG_Callback2_t callbackBaseName, SWIG_Callback3_t callbackPost, SWIG_Callback4_t callbackInitialPropagateWrapper) {
  swig_callbackToString = callbackToString;
  swig_callbackName = callbackName;
  swig_callbackBaseName = callbackBaseName;
  swig_callbackPost = callbackPost;
  swig_callbackInitialPropagateWrapper = callbackInitialPropagateWrapper;
}
 
void SwigDirector_Constraint::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackName = 0;
  swig_callbackBaseName = 0;
  swig_callbackPost = 0;
  swig_callbackInitialPropagateWrapper = 0;
}
 
SwigDirector_SearchMonitor::SwigDirector_SearchMonitor(operations_research::Solver *const s) : operations_research::SearchMonitor(s), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_SearchMonitor::~SwigDirector_SearchMonitor() {
  
}
 
 
std::string SwigDirector_SearchMonitor::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_SearchMonitor::EnterSearch() {
  if (!swig_callbackEnterSearch) {
    operations_research::SearchMonitor::EnterSearch();
    return;
  } else {
    swig_callbackEnterSearch();
  }
}
 
void SwigDirector_SearchMonitor::RestartSearch() {
  if (!swig_callbackRestartSearch) {
    operations_research::SearchMonitor::RestartSearch();
    return;
  } else {
    swig_callbackRestartSearch();
  }
}
 
void SwigDirector_SearchMonitor::ExitSearch() {
  if (!swig_callbackExitSearch) {
    operations_research::SearchMonitor::ExitSearch();
    return;
  } else {
    swig_callbackExitSearch();
  }
}
 
void SwigDirector_SearchMonitor::BeginNextDecision(operations_research::DecisionBuilder *const b) {
  void * jb = 0 ;
  
  if (!swig_callbackBeginNextDecision) {
    operations_research::SearchMonitor::BeginNextDecision(b);
    return;
  } else {
    jb = (void *) b; 
    swig_callbackBeginNextDecision(jb);
  }
}
 
void SwigDirector_SearchMonitor::EndNextDecision(operations_research::DecisionBuilder *const b, operations_research::Decision *const d) {
  void * jb = 0 ;
  void * jd = 0 ;
  
  if (!swig_callbackEndNextDecision) {
    operations_research::SearchMonitor::EndNextDecision(b,d);
    return;
  } else {
    jb = (void *) b; 
    jd = (void *) d; 
    swig_callbackEndNextDecision(jb, jd);
  }
}
 
void SwigDirector_SearchMonitor::ApplyDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackApplyDecision) {
    operations_research::SearchMonitor::ApplyDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackApplyDecision(jd);
  }
}
 
void SwigDirector_SearchMonitor::RefuteDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackRefuteDecision) {
    operations_research::SearchMonitor::RefuteDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackRefuteDecision(jd);
  }
}
 
void SwigDirector_SearchMonitor::AfterDecision(operations_research::Decision *const d, bool apply) {
  void * jd = 0 ;
  unsigned int japply  ;
  
  if (!swig_callbackAfterDecision) {
    operations_research::SearchMonitor::AfterDecision(d,apply);
    return;
  } else {
    jd = (void *) d; 
    japply = apply;
    swig_callbackAfterDecision(jd, japply);
  }
}
 
void SwigDirector_SearchMonitor::BeginFail() {
  if (!swig_callbackBeginFail) {
    operations_research::SearchMonitor::BeginFail();
    return;
  } else {
    swig_callbackBeginFail();
  }
}
 
void SwigDirector_SearchMonitor::EndFail() {
  if (!swig_callbackEndFail) {
    operations_research::SearchMonitor::EndFail();
    return;
  } else {
    swig_callbackEndFail();
  }
}
 
void SwigDirector_SearchMonitor::BeginInitialPropagation() {
  if (!swig_callbackBeginInitialPropagation) {
    operations_research::SearchMonitor::BeginInitialPropagation();
    return;
  } else {
    swig_callbackBeginInitialPropagation();
  }
}
 
void SwigDirector_SearchMonitor::EndInitialPropagation() {
  if (!swig_callbackEndInitialPropagation) {
    operations_research::SearchMonitor::EndInitialPropagation();
    return;
  } else {
    swig_callbackEndInitialPropagation();
  }
}
 
bool SwigDirector_SearchMonitor::AcceptSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAcceptSolution) {
    return operations_research::SearchMonitor::AcceptSolution();
  } else {
    jresult = (unsigned int) swig_callbackAcceptSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SearchMonitor::AtSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAtSolution) {
    return operations_research::SearchMonitor::AtSolution();
  } else {
    jresult = (unsigned int) swig_callbackAtSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SearchMonitor::NoMoreSolutions() {
  if (!swig_callbackNoMoreSolutions) {
    operations_research::SearchMonitor::NoMoreSolutions();
    return;
  } else {
    swig_callbackNoMoreSolutions();
  }
}
 
bool SwigDirector_SearchMonitor::LocalOptimum() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackLocalOptimum) {
    return operations_research::SearchMonitor::LocalOptimum();
  } else {
    jresult = (unsigned int) swig_callbackLocalOptimum();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SearchMonitor::AcceptDelta(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackAcceptDelta) {
    return operations_research::SearchMonitor::AcceptDelta(delta,deltadelta);
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jresult = (unsigned int) swig_callbackAcceptDelta(jdelta, jdeltadelta);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SearchMonitor::AcceptNeighbor() {
  if (!swig_callbackAcceptNeighbor) {
    operations_research::SearchMonitor::AcceptNeighbor();
    return;
  } else {
    swig_callbackAcceptNeighbor();
  }
}
 
void SwigDirector_SearchMonitor::AcceptUncheckedNeighbor() {
  if (!swig_callbackAcceptUncheckedNeighbor) {
    operations_research::SearchMonitor::AcceptUncheckedNeighbor();
    return;
  } else {
    swig_callbackAcceptUncheckedNeighbor();
  }
}
 
bool SwigDirector_SearchMonitor::IsUncheckedSolutionLimitReached() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsUncheckedSolutionLimitReached) {
    return operations_research::SearchMonitor::IsUncheckedSolutionLimitReached();
  } else {
    jresult = (unsigned int) swig_callbackIsUncheckedSolutionLimitReached();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SearchMonitor::PeriodicCheck() {
  if (!swig_callbackPeriodicCheck) {
    operations_research::SearchMonitor::PeriodicCheck();
    return;
  } else {
    swig_callbackPeriodicCheck();
  }
}
 
int SwigDirector_SearchMonitor::ProgressPercent() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackProgressPercent) {
    return operations_research::SearchMonitor::ProgressPercent();
  } else {
    jresult = (int) swig_callbackProgressPercent();
    c_result = (int)jresult; 
  }
  return c_result;
}
 
void SwigDirector_SearchMonitor::Accept(operations_research::ModelVisitor *const visitor) const {
  void * jvisitor = 0 ;
  
  if (!swig_callbackAccept) {
    operations_research::SearchMonitor::Accept(visitor);
    return;
  } else {
    jvisitor = (void *) visitor; 
    swig_callbackAccept(jvisitor);
  }
}
 
void SwigDirector_SearchMonitor::Install() {
  if (!swig_callbackInstall) {
    operations_research::SearchMonitor::Install();
    return;
  } else {
    swig_callbackInstall();
  }
}
 
void SwigDirector_SearchMonitor::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackEnterSearch, SWIG_Callback2_t callbackRestartSearch, SWIG_Callback3_t callbackExitSearch, SWIG_Callback4_t callbackBeginNextDecision, SWIG_Callback5_t callbackEndNextDecision, SWIG_Callback6_t callbackApplyDecision, SWIG_Callback7_t callbackRefuteDecision, SWIG_Callback8_t callbackAfterDecision, SWIG_Callback9_t callbackBeginFail, SWIG_Callback10_t callbackEndFail, SWIG_Callback11_t callbackBeginInitialPropagation, SWIG_Callback12_t callbackEndInitialPropagation, SWIG_Callback13_t callbackAcceptSolution, SWIG_Callback14_t callbackAtSolution, SWIG_Callback15_t callbackNoMoreSolutions, SWIG_Callback16_t callbackLocalOptimum, SWIG_Callback17_t callbackAcceptDelta, SWIG_Callback18_t callbackAcceptNeighbor, SWIG_Callback19_t callbackAcceptUncheckedNeighbor, SWIG_Callback20_t callbackIsUncheckedSolutionLimitReached, SWIG_Callback21_t callbackPeriodicCheck, SWIG_Callback22_t callbackProgressPercent, SWIG_Callback23_t callbackAccept, SWIG_Callback24_t callbackInstall) {
  swig_callbackToString = callbackToString;
  swig_callbackEnterSearch = callbackEnterSearch;
  swig_callbackRestartSearch = callbackRestartSearch;
  swig_callbackExitSearch = callbackExitSearch;
  swig_callbackBeginNextDecision = callbackBeginNextDecision;
  swig_callbackEndNextDecision = callbackEndNextDecision;
  swig_callbackApplyDecision = callbackApplyDecision;
  swig_callbackRefuteDecision = callbackRefuteDecision;
  swig_callbackAfterDecision = callbackAfterDecision;
  swig_callbackBeginFail = callbackBeginFail;
  swig_callbackEndFail = callbackEndFail;
  swig_callbackBeginInitialPropagation = callbackBeginInitialPropagation;
  swig_callbackEndInitialPropagation = callbackEndInitialPropagation;
  swig_callbackAcceptSolution = callbackAcceptSolution;
  swig_callbackAtSolution = callbackAtSolution;
  swig_callbackNoMoreSolutions = callbackNoMoreSolutions;
  swig_callbackLocalOptimum = callbackLocalOptimum;
  swig_callbackAcceptDelta = callbackAcceptDelta;
  swig_callbackAcceptNeighbor = callbackAcceptNeighbor;
  swig_callbackAcceptUncheckedNeighbor = callbackAcceptUncheckedNeighbor;
  swig_callbackIsUncheckedSolutionLimitReached = callbackIsUncheckedSolutionLimitReached;
  swig_callbackPeriodicCheck = callbackPeriodicCheck;
  swig_callbackProgressPercent = callbackProgressPercent;
  swig_callbackAccept = callbackAccept;
  swig_callbackInstall = callbackInstall;
}
 
void SwigDirector_SearchMonitor::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackEnterSearch = 0;
  swig_callbackRestartSearch = 0;
  swig_callbackExitSearch = 0;
  swig_callbackBeginNextDecision = 0;
  swig_callbackEndNextDecision = 0;
  swig_callbackApplyDecision = 0;
  swig_callbackRefuteDecision = 0;
  swig_callbackAfterDecision = 0;
  swig_callbackBeginFail = 0;
  swig_callbackEndFail = 0;
  swig_callbackBeginInitialPropagation = 0;
  swig_callbackEndInitialPropagation = 0;
  swig_callbackAcceptSolution = 0;
  swig_callbackAtSolution = 0;
  swig_callbackNoMoreSolutions = 0;
  swig_callbackLocalOptimum = 0;
  swig_callbackAcceptDelta = 0;
  swig_callbackAcceptNeighbor = 0;
  swig_callbackAcceptUncheckedNeighbor = 0;
  swig_callbackIsUncheckedSolutionLimitReached = 0;
  swig_callbackPeriodicCheck = 0;
  swig_callbackProgressPercent = 0;
  swig_callbackAccept = 0;
  swig_callbackInstall = 0;
}
 
SwigDirector_SolutionCollector::SwigDirector_SolutionCollector(operations_research::Solver *const solver, operations_research::Assignment const *assignment) : operations_research::SolutionCollector(solver, assignment), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_SolutionCollector::SwigDirector_SolutionCollector(operations_research::Solver *const solver) : operations_research::SolutionCollector(solver), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_SolutionCollector::~SwigDirector_SolutionCollector() {
  
}
 
 
std::string SwigDirector_SolutionCollector::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::SolutionCollector::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_SolutionCollector::EnterSearch() {
  if (!swig_callbackEnterSearch) {
    operations_research::SolutionCollector::EnterSearch();
    return;
  } else {
    swig_callbackEnterSearch();
  }
}
 
void SwigDirector_SolutionCollector::RestartSearch() {
  if (!swig_callbackRestartSearch) {
    operations_research::SearchMonitor::RestartSearch();
    return;
  } else {
    swig_callbackRestartSearch();
  }
}
 
void SwigDirector_SolutionCollector::ExitSearch() {
  if (!swig_callbackExitSearch) {
    operations_research::SearchMonitor::ExitSearch();
    return;
  } else {
    swig_callbackExitSearch();
  }
}
 
void SwigDirector_SolutionCollector::BeginNextDecision(operations_research::DecisionBuilder *const b) {
  void * jb = 0 ;
  
  if (!swig_callbackBeginNextDecision) {
    operations_research::SearchMonitor::BeginNextDecision(b);
    return;
  } else {
    jb = (void *) b; 
    swig_callbackBeginNextDecision(jb);
  }
}
 
void SwigDirector_SolutionCollector::EndNextDecision(operations_research::DecisionBuilder *const b, operations_research::Decision *const d) {
  void * jb = 0 ;
  void * jd = 0 ;
  
  if (!swig_callbackEndNextDecision) {
    operations_research::SearchMonitor::EndNextDecision(b,d);
    return;
  } else {
    jb = (void *) b; 
    jd = (void *) d; 
    swig_callbackEndNextDecision(jb, jd);
  }
}
 
void SwigDirector_SolutionCollector::ApplyDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackApplyDecision) {
    operations_research::SearchMonitor::ApplyDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackApplyDecision(jd);
  }
}
 
void SwigDirector_SolutionCollector::RefuteDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackRefuteDecision) {
    operations_research::SearchMonitor::RefuteDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackRefuteDecision(jd);
  }
}
 
void SwigDirector_SolutionCollector::AfterDecision(operations_research::Decision *const d, bool apply) {
  void * jd = 0 ;
  unsigned int japply  ;
  
  if (!swig_callbackAfterDecision) {
    operations_research::SearchMonitor::AfterDecision(d,apply);
    return;
  } else {
    jd = (void *) d; 
    japply = apply;
    swig_callbackAfterDecision(jd, japply);
  }
}
 
void SwigDirector_SolutionCollector::BeginFail() {
  if (!swig_callbackBeginFail) {
    operations_research::SearchMonitor::BeginFail();
    return;
  } else {
    swig_callbackBeginFail();
  }
}
 
void SwigDirector_SolutionCollector::EndFail() {
  if (!swig_callbackEndFail) {
    operations_research::SearchMonitor::EndFail();
    return;
  } else {
    swig_callbackEndFail();
  }
}
 
void SwigDirector_SolutionCollector::BeginInitialPropagation() {
  if (!swig_callbackBeginInitialPropagation) {
    operations_research::SearchMonitor::BeginInitialPropagation();
    return;
  } else {
    swig_callbackBeginInitialPropagation();
  }
}
 
void SwigDirector_SolutionCollector::EndInitialPropagation() {
  if (!swig_callbackEndInitialPropagation) {
    operations_research::SearchMonitor::EndInitialPropagation();
    return;
  } else {
    swig_callbackEndInitialPropagation();
  }
}
 
bool SwigDirector_SolutionCollector::AcceptSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAcceptSolution) {
    return operations_research::SearchMonitor::AcceptSolution();
  } else {
    jresult = (unsigned int) swig_callbackAcceptSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SolutionCollector::AtSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAtSolution) {
    return operations_research::SearchMonitor::AtSolution();
  } else {
    jresult = (unsigned int) swig_callbackAtSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SolutionCollector::NoMoreSolutions() {
  if (!swig_callbackNoMoreSolutions) {
    operations_research::SearchMonitor::NoMoreSolutions();
    return;
  } else {
    swig_callbackNoMoreSolutions();
  }
}
 
bool SwigDirector_SolutionCollector::LocalOptimum() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackLocalOptimum) {
    return operations_research::SearchMonitor::LocalOptimum();
  } else {
    jresult = (unsigned int) swig_callbackLocalOptimum();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SolutionCollector::AcceptDelta(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackAcceptDelta) {
    return operations_research::SearchMonitor::AcceptDelta(delta,deltadelta);
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jresult = (unsigned int) swig_callbackAcceptDelta(jdelta, jdeltadelta);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SolutionCollector::AcceptNeighbor() {
  if (!swig_callbackAcceptNeighbor) {
    operations_research::SearchMonitor::AcceptNeighbor();
    return;
  } else {
    swig_callbackAcceptNeighbor();
  }
}
 
void SwigDirector_SolutionCollector::AcceptUncheckedNeighbor() {
  if (!swig_callbackAcceptUncheckedNeighbor) {
    operations_research::SearchMonitor::AcceptUncheckedNeighbor();
    return;
  } else {
    swig_callbackAcceptUncheckedNeighbor();
  }
}
 
bool SwigDirector_SolutionCollector::IsUncheckedSolutionLimitReached() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsUncheckedSolutionLimitReached) {
    return operations_research::SearchMonitor::IsUncheckedSolutionLimitReached();
  } else {
    jresult = (unsigned int) swig_callbackIsUncheckedSolutionLimitReached();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SolutionCollector::PeriodicCheck() {
  if (!swig_callbackPeriodicCheck) {
    operations_research::SearchMonitor::PeriodicCheck();
    return;
  } else {
    swig_callbackPeriodicCheck();
  }
}
 
int SwigDirector_SolutionCollector::ProgressPercent() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackProgressPercent) {
    return operations_research::SearchMonitor::ProgressPercent();
  } else {
    jresult = (int) swig_callbackProgressPercent();
    c_result = (int)jresult; 
  }
  return c_result;
}
 
void SwigDirector_SolutionCollector::Accept(operations_research::ModelVisitor *const visitor) const {
  void * jvisitor = 0 ;
  
  if (!swig_callbackAccept) {
    operations_research::SearchMonitor::Accept(visitor);
    return;
  } else {
    jvisitor = (void *) visitor; 
    swig_callbackAccept(jvisitor);
  }
}
 
void SwigDirector_SolutionCollector::Install() {
  if (!swig_callbackInstall) {
    operations_research::SearchMonitor::Install();
    return;
  } else {
    swig_callbackInstall();
  }
}
 
void SwigDirector_SolutionCollector::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackEnterSearch, SWIG_Callback2_t callbackRestartSearch, SWIG_Callback3_t callbackExitSearch, SWIG_Callback4_t callbackBeginNextDecision, SWIG_Callback5_t callbackEndNextDecision, SWIG_Callback6_t callbackApplyDecision, SWIG_Callback7_t callbackRefuteDecision, SWIG_Callback8_t callbackAfterDecision, SWIG_Callback9_t callbackBeginFail, SWIG_Callback10_t callbackEndFail, SWIG_Callback11_t callbackBeginInitialPropagation, SWIG_Callback12_t callbackEndInitialPropagation, SWIG_Callback13_t callbackAcceptSolution, SWIG_Callback14_t callbackAtSolution, SWIG_Callback15_t callbackNoMoreSolutions, SWIG_Callback16_t callbackLocalOptimum, SWIG_Callback17_t callbackAcceptDelta, SWIG_Callback18_t callbackAcceptNeighbor, SWIG_Callback19_t callbackAcceptUncheckedNeighbor, SWIG_Callback20_t callbackIsUncheckedSolutionLimitReached, SWIG_Callback21_t callbackPeriodicCheck, SWIG_Callback22_t callbackProgressPercent, SWIG_Callback23_t callbackAccept, SWIG_Callback24_t callbackInstall) {
  swig_callbackToString = callbackToString;
  swig_callbackEnterSearch = callbackEnterSearch;
  swig_callbackRestartSearch = callbackRestartSearch;
  swig_callbackExitSearch = callbackExitSearch;
  swig_callbackBeginNextDecision = callbackBeginNextDecision;
  swig_callbackEndNextDecision = callbackEndNextDecision;
  swig_callbackApplyDecision = callbackApplyDecision;
  swig_callbackRefuteDecision = callbackRefuteDecision;
  swig_callbackAfterDecision = callbackAfterDecision;
  swig_callbackBeginFail = callbackBeginFail;
  swig_callbackEndFail = callbackEndFail;
  swig_callbackBeginInitialPropagation = callbackBeginInitialPropagation;
  swig_callbackEndInitialPropagation = callbackEndInitialPropagation;
  swig_callbackAcceptSolution = callbackAcceptSolution;
  swig_callbackAtSolution = callbackAtSolution;
  swig_callbackNoMoreSolutions = callbackNoMoreSolutions;
  swig_callbackLocalOptimum = callbackLocalOptimum;
  swig_callbackAcceptDelta = callbackAcceptDelta;
  swig_callbackAcceptNeighbor = callbackAcceptNeighbor;
  swig_callbackAcceptUncheckedNeighbor = callbackAcceptUncheckedNeighbor;
  swig_callbackIsUncheckedSolutionLimitReached = callbackIsUncheckedSolutionLimitReached;
  swig_callbackPeriodicCheck = callbackPeriodicCheck;
  swig_callbackProgressPercent = callbackProgressPercent;
  swig_callbackAccept = callbackAccept;
  swig_callbackInstall = callbackInstall;
}
 
void SwigDirector_SolutionCollector::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackEnterSearch = 0;
  swig_callbackRestartSearch = 0;
  swig_callbackExitSearch = 0;
  swig_callbackBeginNextDecision = 0;
  swig_callbackEndNextDecision = 0;
  swig_callbackApplyDecision = 0;
  swig_callbackRefuteDecision = 0;
  swig_callbackAfterDecision = 0;
  swig_callbackBeginFail = 0;
  swig_callbackEndFail = 0;
  swig_callbackBeginInitialPropagation = 0;
  swig_callbackEndInitialPropagation = 0;
  swig_callbackAcceptSolution = 0;
  swig_callbackAtSolution = 0;
  swig_callbackNoMoreSolutions = 0;
  swig_callbackLocalOptimum = 0;
  swig_callbackAcceptDelta = 0;
  swig_callbackAcceptNeighbor = 0;
  swig_callbackAcceptUncheckedNeighbor = 0;
  swig_callbackIsUncheckedSolutionLimitReached = 0;
  swig_callbackPeriodicCheck = 0;
  swig_callbackProgressPercent = 0;
  swig_callbackAccept = 0;
  swig_callbackInstall = 0;
}
 
SwigDirector_OptimizeVar::SwigDirector_OptimizeVar(operations_research::Solver *const s, bool maximize, operations_research::IntVar *const a, int64_t step) : operations_research::OptimizeVar(s, maximize, a, step), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_OptimizeVar::~SwigDirector_OptimizeVar() {
  
}
 
 
std::string SwigDirector_OptimizeVar::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::OptimizeVar::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_OptimizeVar::EnterSearch() {
  if (!swig_callbackEnterSearch) {
    operations_research::OptimizeVar::EnterSearch();
    return;
  } else {
    swig_callbackEnterSearch();
  }
}
 
void SwigDirector_OptimizeVar::RestartSearch() {
  if (!swig_callbackRestartSearch) {
    operations_research::SearchMonitor::RestartSearch();
    return;
  } else {
    swig_callbackRestartSearch();
  }
}
 
void SwigDirector_OptimizeVar::ExitSearch() {
  if (!swig_callbackExitSearch) {
    operations_research::SearchMonitor::ExitSearch();
    return;
  } else {
    swig_callbackExitSearch();
  }
}
 
void SwigDirector_OptimizeVar::BeginNextDecision(operations_research::DecisionBuilder *const db) {
  void * jdb = 0 ;
  
  if (!swig_callbackBeginNextDecision) {
    operations_research::OptimizeVar::BeginNextDecision(db);
    return;
  } else {
    jdb = (void *) db; 
    swig_callbackBeginNextDecision(jdb);
  }
}
 
void SwigDirector_OptimizeVar::EndNextDecision(operations_research::DecisionBuilder *const b, operations_research::Decision *const d) {
  void * jb = 0 ;
  void * jd = 0 ;
  
  if (!swig_callbackEndNextDecision) {
    operations_research::SearchMonitor::EndNextDecision(b,d);
    return;
  } else {
    jb = (void *) b; 
    jd = (void *) d; 
    swig_callbackEndNextDecision(jb, jd);
  }
}
 
void SwigDirector_OptimizeVar::ApplyDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackApplyDecision) {
    operations_research::SearchMonitor::ApplyDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackApplyDecision(jd);
  }
}
 
void SwigDirector_OptimizeVar::RefuteDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackRefuteDecision) {
    operations_research::OptimizeVar::RefuteDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackRefuteDecision(jd);
  }
}
 
void SwigDirector_OptimizeVar::AfterDecision(operations_research::Decision *const d, bool apply) {
  void * jd = 0 ;
  unsigned int japply  ;
  
  if (!swig_callbackAfterDecision) {
    operations_research::SearchMonitor::AfterDecision(d,apply);
    return;
  } else {
    jd = (void *) d; 
    japply = apply;
    swig_callbackAfterDecision(jd, japply);
  }
}
 
void SwigDirector_OptimizeVar::BeginFail() {
  if (!swig_callbackBeginFail) {
    operations_research::SearchMonitor::BeginFail();
    return;
  } else {
    swig_callbackBeginFail();
  }
}
 
void SwigDirector_OptimizeVar::EndFail() {
  if (!swig_callbackEndFail) {
    operations_research::SearchMonitor::EndFail();
    return;
  } else {
    swig_callbackEndFail();
  }
}
 
void SwigDirector_OptimizeVar::BeginInitialPropagation() {
  if (!swig_callbackBeginInitialPropagation) {
    operations_research::SearchMonitor::BeginInitialPropagation();
    return;
  } else {
    swig_callbackBeginInitialPropagation();
  }
}
 
void SwigDirector_OptimizeVar::EndInitialPropagation() {
  if (!swig_callbackEndInitialPropagation) {
    operations_research::SearchMonitor::EndInitialPropagation();
    return;
  } else {
    swig_callbackEndInitialPropagation();
  }
}
 
bool SwigDirector_OptimizeVar::AcceptSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAcceptSolution) {
    return operations_research::OptimizeVar::AcceptSolution();
  } else {
    jresult = (unsigned int) swig_callbackAcceptSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_OptimizeVar::AtSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAtSolution) {
    return operations_research::OptimizeVar::AtSolution();
  } else {
    jresult = (unsigned int) swig_callbackAtSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_OptimizeVar::NoMoreSolutions() {
  if (!swig_callbackNoMoreSolutions) {
    operations_research::SearchMonitor::NoMoreSolutions();
    return;
  } else {
    swig_callbackNoMoreSolutions();
  }
}
 
bool SwigDirector_OptimizeVar::LocalOptimum() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackLocalOptimum) {
    return operations_research::SearchMonitor::LocalOptimum();
  } else {
    jresult = (unsigned int) swig_callbackLocalOptimum();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_OptimizeVar::AcceptDelta(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackAcceptDelta) {
    return operations_research::OptimizeVar::AcceptDelta(delta,deltadelta);
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jresult = (unsigned int) swig_callbackAcceptDelta(jdelta, jdeltadelta);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_OptimizeVar::AcceptNeighbor() {
  if (!swig_callbackAcceptNeighbor) {
    operations_research::SearchMonitor::AcceptNeighbor();
    return;
  } else {
    swig_callbackAcceptNeighbor();
  }
}
 
void SwigDirector_OptimizeVar::AcceptUncheckedNeighbor() {
  if (!swig_callbackAcceptUncheckedNeighbor) {
    operations_research::SearchMonitor::AcceptUncheckedNeighbor();
    return;
  } else {
    swig_callbackAcceptUncheckedNeighbor();
  }
}
 
bool SwigDirector_OptimizeVar::IsUncheckedSolutionLimitReached() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsUncheckedSolutionLimitReached) {
    return operations_research::SearchMonitor::IsUncheckedSolutionLimitReached();
  } else {
    jresult = (unsigned int) swig_callbackIsUncheckedSolutionLimitReached();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_OptimizeVar::PeriodicCheck() {
  if (!swig_callbackPeriodicCheck) {
    operations_research::SearchMonitor::PeriodicCheck();
    return;
  } else {
    swig_callbackPeriodicCheck();
  }
}
 
int SwigDirector_OptimizeVar::ProgressPercent() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackProgressPercent) {
    return operations_research::SearchMonitor::ProgressPercent();
  } else {
    jresult = (int) swig_callbackProgressPercent();
    c_result = (int)jresult; 
  }
  return c_result;
}
 
void SwigDirector_OptimizeVar::Accept(operations_research::ModelVisitor *const visitor) const {
  void * jvisitor = 0 ;
  
  if (!swig_callbackAccept) {
    operations_research::OptimizeVar::Accept(visitor);
    return;
  } else {
    jvisitor = (void *) visitor; 
    swig_callbackAccept(jvisitor);
  }
}
 
void SwigDirector_OptimizeVar::Install() {
  if (!swig_callbackInstall) {
    operations_research::SearchMonitor::Install();
    return;
  } else {
    swig_callbackInstall();
  }
}
 
std::string SwigDirector_OptimizeVar::Print() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackPrint) {
    return operations_research::OptimizeVar::Print();
  } else {
    jresult = (char *) swig_callbackPrint();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_OptimizeVar::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackEnterSearch, SWIG_Callback2_t callbackRestartSearch, SWIG_Callback3_t callbackExitSearch, SWIG_Callback4_t callbackBeginNextDecision, SWIG_Callback5_t callbackEndNextDecision, SWIG_Callback6_t callbackApplyDecision, SWIG_Callback7_t callbackRefuteDecision, SWIG_Callback8_t callbackAfterDecision, SWIG_Callback9_t callbackBeginFail, SWIG_Callback10_t callbackEndFail, SWIG_Callback11_t callbackBeginInitialPropagation, SWIG_Callback12_t callbackEndInitialPropagation, SWIG_Callback13_t callbackAcceptSolution, SWIG_Callback14_t callbackAtSolution, SWIG_Callback15_t callbackNoMoreSolutions, SWIG_Callback16_t callbackLocalOptimum, SWIG_Callback17_t callbackAcceptDelta, SWIG_Callback18_t callbackAcceptNeighbor, SWIG_Callback19_t callbackAcceptUncheckedNeighbor, SWIG_Callback20_t callbackIsUncheckedSolutionLimitReached, SWIG_Callback21_t callbackPeriodicCheck, SWIG_Callback22_t callbackProgressPercent, SWIG_Callback23_t callbackAccept, SWIG_Callback24_t callbackInstall, SWIG_Callback25_t callbackPrint) {
  swig_callbackToString = callbackToString;
  swig_callbackEnterSearch = callbackEnterSearch;
  swig_callbackRestartSearch = callbackRestartSearch;
  swig_callbackExitSearch = callbackExitSearch;
  swig_callbackBeginNextDecision = callbackBeginNextDecision;
  swig_callbackEndNextDecision = callbackEndNextDecision;
  swig_callbackApplyDecision = callbackApplyDecision;
  swig_callbackRefuteDecision = callbackRefuteDecision;
  swig_callbackAfterDecision = callbackAfterDecision;
  swig_callbackBeginFail = callbackBeginFail;
  swig_callbackEndFail = callbackEndFail;
  swig_callbackBeginInitialPropagation = callbackBeginInitialPropagation;
  swig_callbackEndInitialPropagation = callbackEndInitialPropagation;
  swig_callbackAcceptSolution = callbackAcceptSolution;
  swig_callbackAtSolution = callbackAtSolution;
  swig_callbackNoMoreSolutions = callbackNoMoreSolutions;
  swig_callbackLocalOptimum = callbackLocalOptimum;
  swig_callbackAcceptDelta = callbackAcceptDelta;
  swig_callbackAcceptNeighbor = callbackAcceptNeighbor;
  swig_callbackAcceptUncheckedNeighbor = callbackAcceptUncheckedNeighbor;
  swig_callbackIsUncheckedSolutionLimitReached = callbackIsUncheckedSolutionLimitReached;
  swig_callbackPeriodicCheck = callbackPeriodicCheck;
  swig_callbackProgressPercent = callbackProgressPercent;
  swig_callbackAccept = callbackAccept;
  swig_callbackInstall = callbackInstall;
  swig_callbackPrint = callbackPrint;
}
 
void SwigDirector_OptimizeVar::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackEnterSearch = 0;
  swig_callbackRestartSearch = 0;
  swig_callbackExitSearch = 0;
  swig_callbackBeginNextDecision = 0;
  swig_callbackEndNextDecision = 0;
  swig_callbackApplyDecision = 0;
  swig_callbackRefuteDecision = 0;
  swig_callbackAfterDecision = 0;
  swig_callbackBeginFail = 0;
  swig_callbackEndFail = 0;
  swig_callbackBeginInitialPropagation = 0;
  swig_callbackEndInitialPropagation = 0;
  swig_callbackAcceptSolution = 0;
  swig_callbackAtSolution = 0;
  swig_callbackNoMoreSolutions = 0;
  swig_callbackLocalOptimum = 0;
  swig_callbackAcceptDelta = 0;
  swig_callbackAcceptNeighbor = 0;
  swig_callbackAcceptUncheckedNeighbor = 0;
  swig_callbackIsUncheckedSolutionLimitReached = 0;
  swig_callbackPeriodicCheck = 0;
  swig_callbackProgressPercent = 0;
  swig_callbackAccept = 0;
  swig_callbackInstall = 0;
  swig_callbackPrint = 0;
}
 
SwigDirector_SearchLimit::SwigDirector_SearchLimit(operations_research::Solver *const s) : operations_research::SearchLimit(s), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_SearchLimit::~SwigDirector_SearchLimit() {
  
}
 
 
std::string SwigDirector_SearchLimit::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::SearchLimit::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_SearchLimit::EnterSearch() {
  if (!swig_callbackEnterSearch) {
    operations_research::SearchLimit::EnterSearch();
    return;
  } else {
    swig_callbackEnterSearch();
  }
}
 
void SwigDirector_SearchLimit::RestartSearch() {
  if (!swig_callbackRestartSearch) {
    operations_research::SearchMonitor::RestartSearch();
    return;
  } else {
    swig_callbackRestartSearch();
  }
}
 
void SwigDirector_SearchLimit::ExitSearch() {
  if (!swig_callbackExitSearch) {
    operations_research::SearchMonitor::ExitSearch();
    return;
  } else {
    swig_callbackExitSearch();
  }
}
 
void SwigDirector_SearchLimit::BeginNextDecision(operations_research::DecisionBuilder *const b) {
  void * jb = 0 ;
  
  if (!swig_callbackBeginNextDecision) {
    operations_research::SearchLimit::BeginNextDecision(b);
    return;
  } else {
    jb = (void *) b; 
    swig_callbackBeginNextDecision(jb);
  }
}
 
void SwigDirector_SearchLimit::EndNextDecision(operations_research::DecisionBuilder *const b, operations_research::Decision *const d) {
  void * jb = 0 ;
  void * jd = 0 ;
  
  if (!swig_callbackEndNextDecision) {
    operations_research::SearchMonitor::EndNextDecision(b,d);
    return;
  } else {
    jb = (void *) b; 
    jd = (void *) d; 
    swig_callbackEndNextDecision(jb, jd);
  }
}
 
void SwigDirector_SearchLimit::ApplyDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackApplyDecision) {
    operations_research::SearchMonitor::ApplyDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackApplyDecision(jd);
  }
}
 
void SwigDirector_SearchLimit::RefuteDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackRefuteDecision) {
    operations_research::SearchLimit::RefuteDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackRefuteDecision(jd);
  }
}
 
void SwigDirector_SearchLimit::AfterDecision(operations_research::Decision *const d, bool apply) {
  void * jd = 0 ;
  unsigned int japply  ;
  
  if (!swig_callbackAfterDecision) {
    operations_research::SearchMonitor::AfterDecision(d,apply);
    return;
  } else {
    jd = (void *) d; 
    japply = apply;
    swig_callbackAfterDecision(jd, japply);
  }
}
 
void SwigDirector_SearchLimit::BeginFail() {
  if (!swig_callbackBeginFail) {
    operations_research::SearchMonitor::BeginFail();
    return;
  } else {
    swig_callbackBeginFail();
  }
}
 
void SwigDirector_SearchLimit::EndFail() {
  if (!swig_callbackEndFail) {
    operations_research::SearchMonitor::EndFail();
    return;
  } else {
    swig_callbackEndFail();
  }
}
 
void SwigDirector_SearchLimit::BeginInitialPropagation() {
  if (!swig_callbackBeginInitialPropagation) {
    operations_research::SearchMonitor::BeginInitialPropagation();
    return;
  } else {
    swig_callbackBeginInitialPropagation();
  }
}
 
void SwigDirector_SearchLimit::EndInitialPropagation() {
  if (!swig_callbackEndInitialPropagation) {
    operations_research::SearchMonitor::EndInitialPropagation();
    return;
  } else {
    swig_callbackEndInitialPropagation();
  }
}
 
bool SwigDirector_SearchLimit::AcceptSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAcceptSolution) {
    return operations_research::SearchMonitor::AcceptSolution();
  } else {
    jresult = (unsigned int) swig_callbackAcceptSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SearchLimit::AtSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAtSolution) {
    return operations_research::SearchMonitor::AtSolution();
  } else {
    jresult = (unsigned int) swig_callbackAtSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SearchLimit::NoMoreSolutions() {
  if (!swig_callbackNoMoreSolutions) {
    operations_research::SearchMonitor::NoMoreSolutions();
    return;
  } else {
    swig_callbackNoMoreSolutions();
  }
}
 
bool SwigDirector_SearchLimit::LocalOptimum() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackLocalOptimum) {
    return operations_research::SearchMonitor::LocalOptimum();
  } else {
    jresult = (unsigned int) swig_callbackLocalOptimum();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SearchLimit::AcceptDelta(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackAcceptDelta) {
    return operations_research::SearchMonitor::AcceptDelta(delta,deltadelta);
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jresult = (unsigned int) swig_callbackAcceptDelta(jdelta, jdeltadelta);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SearchLimit::AcceptNeighbor() {
  if (!swig_callbackAcceptNeighbor) {
    operations_research::SearchMonitor::AcceptNeighbor();
    return;
  } else {
    swig_callbackAcceptNeighbor();
  }
}
 
void SwigDirector_SearchLimit::AcceptUncheckedNeighbor() {
  if (!swig_callbackAcceptUncheckedNeighbor) {
    operations_research::SearchMonitor::AcceptUncheckedNeighbor();
    return;
  } else {
    swig_callbackAcceptUncheckedNeighbor();
  }
}
 
bool SwigDirector_SearchLimit::IsUncheckedSolutionLimitReached() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsUncheckedSolutionLimitReached) {
    return operations_research::SearchMonitor::IsUncheckedSolutionLimitReached();
  } else {
    jresult = (unsigned int) swig_callbackIsUncheckedSolutionLimitReached();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SearchLimit::PeriodicCheck() {
  if (!swig_callbackPeriodicCheck) {
    operations_research::SearchLimit::PeriodicCheck();
    return;
  } else {
    swig_callbackPeriodicCheck();
  }
}
 
int SwigDirector_SearchLimit::ProgressPercent() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackProgressPercent) {
    return operations_research::SearchMonitor::ProgressPercent();
  } else {
    jresult = (int) swig_callbackProgressPercent();
    c_result = (int)jresult; 
  }
  return c_result;
}
 
void SwigDirector_SearchLimit::Accept(operations_research::ModelVisitor *const visitor) const {
  void * jvisitor = 0 ;
  
  if (!swig_callbackAccept) {
    operations_research::SearchMonitor::Accept(visitor);
    return;
  } else {
    jvisitor = (void *) visitor; 
    swig_callbackAccept(jvisitor);
  }
}
 
void SwigDirector_SearchLimit::Install() {
  if (!swig_callbackInstall) {
    operations_research::SearchMonitor::Install();
    return;
  } else {
    swig_callbackInstall();
  }
}
 
bool SwigDirector_SearchLimit::Check() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackCheck) {
    Swig::DirectorPureVirtualException::raise("operations_research::SearchLimit::Check");
    return c_result;
  } else {
    jresult = (unsigned int) swig_callbackCheck();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SearchLimit::Init() {
  if (!swig_callbackInit) {
    Swig::DirectorPureVirtualException::raise("operations_research::SearchLimit::Init");
    return;
  } else {
    swig_callbackInit();
  }
}
 
void SwigDirector_SearchLimit::Copy(operations_research::SearchLimit const *const limit) {
  void * jlimit = 0 ;
  
  if (!swig_callbackCopy) {
    Swig::DirectorPureVirtualException::raise("operations_research::SearchLimit::Copy");
    return;
  } else {
    jlimit = (void *) limit; 
    swig_callbackCopy(jlimit);
  }
}
 
operations_research::SearchLimit *SwigDirector_SearchLimit::MakeClone() const {
  operations_research::SearchLimit *c_result = 0 ;
  void * jresult = 0 ;
  
  if (!swig_callbackMakeClone) {
    Swig::DirectorPureVirtualException::raise("operations_research::SearchLimit::MakeClone");
    return c_result;
  } else {
    jresult = (void *) swig_callbackMakeClone();
    c_result = (operations_research::SearchLimit *)jresult; 
  }
  return c_result;
}
 
void SwigDirector_SearchLimit::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackEnterSearch, SWIG_Callback2_t callbackRestartSearch, SWIG_Callback3_t callbackExitSearch, SWIG_Callback4_t callbackBeginNextDecision, SWIG_Callback5_t callbackEndNextDecision, SWIG_Callback6_t callbackApplyDecision, SWIG_Callback7_t callbackRefuteDecision, SWIG_Callback8_t callbackAfterDecision, SWIG_Callback9_t callbackBeginFail, SWIG_Callback10_t callbackEndFail, SWIG_Callback11_t callbackBeginInitialPropagation, SWIG_Callback12_t callbackEndInitialPropagation, SWIG_Callback13_t callbackAcceptSolution, SWIG_Callback14_t callbackAtSolution, SWIG_Callback15_t callbackNoMoreSolutions, SWIG_Callback16_t callbackLocalOptimum, SWIG_Callback17_t callbackAcceptDelta, SWIG_Callback18_t callbackAcceptNeighbor, SWIG_Callback19_t callbackAcceptUncheckedNeighbor, SWIG_Callback20_t callbackIsUncheckedSolutionLimitReached, SWIG_Callback21_t callbackPeriodicCheck, SWIG_Callback22_t callbackProgressPercent, SWIG_Callback23_t callbackAccept, SWIG_Callback24_t callbackInstall, SWIG_Callback25_t callbackCheck, SWIG_Callback26_t callbackInit, SWIG_Callback27_t callbackCopy, SWIG_Callback28_t callbackMakeClone) {
  swig_callbackToString = callbackToString;
  swig_callbackEnterSearch = callbackEnterSearch;
  swig_callbackRestartSearch = callbackRestartSearch;
  swig_callbackExitSearch = callbackExitSearch;
  swig_callbackBeginNextDecision = callbackBeginNextDecision;
  swig_callbackEndNextDecision = callbackEndNextDecision;
  swig_callbackApplyDecision = callbackApplyDecision;
  swig_callbackRefuteDecision = callbackRefuteDecision;
  swig_callbackAfterDecision = callbackAfterDecision;
  swig_callbackBeginFail = callbackBeginFail;
  swig_callbackEndFail = callbackEndFail;
  swig_callbackBeginInitialPropagation = callbackBeginInitialPropagation;
  swig_callbackEndInitialPropagation = callbackEndInitialPropagation;
  swig_callbackAcceptSolution = callbackAcceptSolution;
  swig_callbackAtSolution = callbackAtSolution;
  swig_callbackNoMoreSolutions = callbackNoMoreSolutions;
  swig_callbackLocalOptimum = callbackLocalOptimum;
  swig_callbackAcceptDelta = callbackAcceptDelta;
  swig_callbackAcceptNeighbor = callbackAcceptNeighbor;
  swig_callbackAcceptUncheckedNeighbor = callbackAcceptUncheckedNeighbor;
  swig_callbackIsUncheckedSolutionLimitReached = callbackIsUncheckedSolutionLimitReached;
  swig_callbackPeriodicCheck = callbackPeriodicCheck;
  swig_callbackProgressPercent = callbackProgressPercent;
  swig_callbackAccept = callbackAccept;
  swig_callbackInstall = callbackInstall;
  swig_callbackCheck = callbackCheck;
  swig_callbackInit = callbackInit;
  swig_callbackCopy = callbackCopy;
  swig_callbackMakeClone = callbackMakeClone;
}
 
void SwigDirector_SearchLimit::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackEnterSearch = 0;
  swig_callbackRestartSearch = 0;
  swig_callbackExitSearch = 0;
  swig_callbackBeginNextDecision = 0;
  swig_callbackEndNextDecision = 0;
  swig_callbackApplyDecision = 0;
  swig_callbackRefuteDecision = 0;
  swig_callbackAfterDecision = 0;
  swig_callbackBeginFail = 0;
  swig_callbackEndFail = 0;
  swig_callbackBeginInitialPropagation = 0;
  swig_callbackEndInitialPropagation = 0;
  swig_callbackAcceptSolution = 0;
  swig_callbackAtSolution = 0;
  swig_callbackNoMoreSolutions = 0;
  swig_callbackLocalOptimum = 0;
  swig_callbackAcceptDelta = 0;
  swig_callbackAcceptNeighbor = 0;
  swig_callbackAcceptUncheckedNeighbor = 0;
  swig_callbackIsUncheckedSolutionLimitReached = 0;
  swig_callbackPeriodicCheck = 0;
  swig_callbackProgressPercent = 0;
  swig_callbackAccept = 0;
  swig_callbackInstall = 0;
  swig_callbackCheck = 0;
  swig_callbackInit = 0;
  swig_callbackCopy = 0;
  swig_callbackMakeClone = 0;
}
 
SwigDirector_RegularLimit::SwigDirector_RegularLimit(operations_research::Solver *const s, absl::Duration time, int64_t branches, int64_t failures, int64_t solutions, bool smart_time_check, bool cumulative) : operations_research::RegularLimit(s, time, branches, failures, solutions, smart_time_check, cumulative), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_RegularLimit::~SwigDirector_RegularLimit() {
  
}
 
 
std::string SwigDirector_RegularLimit::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::RegularLimit::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_RegularLimit::EnterSearch() {
  if (!swig_callbackEnterSearch) {
    operations_research::SearchLimit::EnterSearch();
    return;
  } else {
    swig_callbackEnterSearch();
  }
}
 
void SwigDirector_RegularLimit::RestartSearch() {
  if (!swig_callbackRestartSearch) {
    operations_research::SearchMonitor::RestartSearch();
    return;
  } else {
    swig_callbackRestartSearch();
  }
}
 
void SwigDirector_RegularLimit::ExitSearch() {
  if (!swig_callbackExitSearch) {
    operations_research::RegularLimit::ExitSearch();
    return;
  } else {
    swig_callbackExitSearch();
  }
}
 
void SwigDirector_RegularLimit::BeginNextDecision(operations_research::DecisionBuilder *const b) {
  void * jb = 0 ;
  
  if (!swig_callbackBeginNextDecision) {
    operations_research::SearchLimit::BeginNextDecision(b);
    return;
  } else {
    jb = (void *) b; 
    swig_callbackBeginNextDecision(jb);
  }
}
 
void SwigDirector_RegularLimit::EndNextDecision(operations_research::DecisionBuilder *const b, operations_research::Decision *const d) {
  void * jb = 0 ;
  void * jd = 0 ;
  
  if (!swig_callbackEndNextDecision) {
    operations_research::SearchMonitor::EndNextDecision(b,d);
    return;
  } else {
    jb = (void *) b; 
    jd = (void *) d; 
    swig_callbackEndNextDecision(jb, jd);
  }
}
 
void SwigDirector_RegularLimit::ApplyDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackApplyDecision) {
    operations_research::SearchMonitor::ApplyDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackApplyDecision(jd);
  }
}
 
void SwigDirector_RegularLimit::RefuteDecision(operations_research::Decision *const d) {
  void * jd = 0 ;
  
  if (!swig_callbackRefuteDecision) {
    operations_research::SearchLimit::RefuteDecision(d);
    return;
  } else {
    jd = (void *) d; 
    swig_callbackRefuteDecision(jd);
  }
}
 
void SwigDirector_RegularLimit::AfterDecision(operations_research::Decision *const d, bool apply) {
  void * jd = 0 ;
  unsigned int japply  ;
  
  if (!swig_callbackAfterDecision) {
    operations_research::SearchMonitor::AfterDecision(d,apply);
    return;
  } else {
    jd = (void *) d; 
    japply = apply;
    swig_callbackAfterDecision(jd, japply);
  }
}
 
void SwigDirector_RegularLimit::BeginFail() {
  if (!swig_callbackBeginFail) {
    operations_research::SearchMonitor::BeginFail();
    return;
  } else {
    swig_callbackBeginFail();
  }
}
 
void SwigDirector_RegularLimit::EndFail() {
  if (!swig_callbackEndFail) {
    operations_research::SearchMonitor::EndFail();
    return;
  } else {
    swig_callbackEndFail();
  }
}
 
void SwigDirector_RegularLimit::BeginInitialPropagation() {
  if (!swig_callbackBeginInitialPropagation) {
    operations_research::SearchMonitor::BeginInitialPropagation();
    return;
  } else {
    swig_callbackBeginInitialPropagation();
  }
}
 
void SwigDirector_RegularLimit::EndInitialPropagation() {
  if (!swig_callbackEndInitialPropagation) {
    operations_research::SearchMonitor::EndInitialPropagation();
    return;
  } else {
    swig_callbackEndInitialPropagation();
  }
}
 
bool SwigDirector_RegularLimit::AcceptSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAcceptSolution) {
    return operations_research::SearchMonitor::AcceptSolution();
  } else {
    jresult = (unsigned int) swig_callbackAcceptSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_RegularLimit::AtSolution() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackAtSolution) {
    return operations_research::SearchMonitor::AtSolution();
  } else {
    jresult = (unsigned int) swig_callbackAtSolution();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_RegularLimit::NoMoreSolutions() {
  if (!swig_callbackNoMoreSolutions) {
    operations_research::SearchMonitor::NoMoreSolutions();
    return;
  } else {
    swig_callbackNoMoreSolutions();
  }
}
 
bool SwigDirector_RegularLimit::LocalOptimum() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackLocalOptimum) {
    return operations_research::SearchMonitor::LocalOptimum();
  } else {
    jresult = (unsigned int) swig_callbackLocalOptimum();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_RegularLimit::AcceptDelta(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackAcceptDelta) {
    return operations_research::SearchMonitor::AcceptDelta(delta,deltadelta);
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jresult = (unsigned int) swig_callbackAcceptDelta(jdelta, jdeltadelta);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_RegularLimit::AcceptNeighbor() {
  if (!swig_callbackAcceptNeighbor) {
    operations_research::SearchMonitor::AcceptNeighbor();
    return;
  } else {
    swig_callbackAcceptNeighbor();
  }
}
 
void SwigDirector_RegularLimit::AcceptUncheckedNeighbor() {
  if (!swig_callbackAcceptUncheckedNeighbor) {
    operations_research::SearchMonitor::AcceptUncheckedNeighbor();
    return;
  } else {
    swig_callbackAcceptUncheckedNeighbor();
  }
}
 
bool SwigDirector_RegularLimit::IsUncheckedSolutionLimitReached() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsUncheckedSolutionLimitReached) {
    return operations_research::RegularLimit::IsUncheckedSolutionLimitReached();
  } else {
    jresult = (unsigned int) swig_callbackIsUncheckedSolutionLimitReached();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_RegularLimit::PeriodicCheck() {
  if (!swig_callbackPeriodicCheck) {
    operations_research::SearchLimit::PeriodicCheck();
    return;
  } else {
    swig_callbackPeriodicCheck();
  }
}
 
int SwigDirector_RegularLimit::ProgressPercent() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackProgressPercent) {
    return operations_research::RegularLimit::ProgressPercent();
  } else {
    jresult = (int) swig_callbackProgressPercent();
    c_result = (int)jresult; 
  }
  return c_result;
}
 
void SwigDirector_RegularLimit::Accept(operations_research::ModelVisitor *const visitor) const {
  void * jvisitor = 0 ;
  
  if (!swig_callbackAccept) {
    operations_research::RegularLimit::Accept(visitor);
    return;
  } else {
    jvisitor = (void *) visitor; 
    swig_callbackAccept(jvisitor);
  }
}
 
void SwigDirector_RegularLimit::Install() {
  if (!swig_callbackInstall) {
    operations_research::SearchMonitor::Install();
    return;
  } else {
    swig_callbackInstall();
  }
}
 
bool SwigDirector_RegularLimit::Check() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackCheck) {
    return operations_research::RegularLimit::Check();
  } else {
    jresult = (unsigned int) swig_callbackCheck();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_RegularLimit::Init() {
  if (!swig_callbackInit) {
    operations_research::RegularLimit::Init();
    return;
  } else {
    swig_callbackInit();
  }
}
 
void SwigDirector_RegularLimit::Copy(operations_research::SearchLimit const *const limit) {
  void * jlimit = 0 ;
  
  if (!swig_callbackCopy) {
    operations_research::RegularLimit::Copy(limit);
    return;
  } else {
    jlimit = (void *) limit; 
    swig_callbackCopy(jlimit);
  }
}
 
operations_research::SearchLimit *SwigDirector_RegularLimit::MakeClone() const {
  operations_research::SearchLimit *c_result = 0 ;
  void * jresult = 0 ;
  
  if (!swig_callbackMakeClone) {
    return operations_research::RegularLimit::MakeClone();
  } else {
    jresult = (void *) swig_callbackMakeClone();
    c_result = (operations_research::SearchLimit *)jresult; 
  }
  return c_result;
}
 
void SwigDirector_RegularLimit::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackEnterSearch, SWIG_Callback2_t callbackRestartSearch, SWIG_Callback3_t callbackExitSearch, SWIG_Callback4_t callbackBeginNextDecision, SWIG_Callback5_t callbackEndNextDecision, SWIG_Callback6_t callbackApplyDecision, SWIG_Callback7_t callbackRefuteDecision, SWIG_Callback8_t callbackAfterDecision, SWIG_Callback9_t callbackBeginFail, SWIG_Callback10_t callbackEndFail, SWIG_Callback11_t callbackBeginInitialPropagation, SWIG_Callback12_t callbackEndInitialPropagation, SWIG_Callback13_t callbackAcceptSolution, SWIG_Callback14_t callbackAtSolution, SWIG_Callback15_t callbackNoMoreSolutions, SWIG_Callback16_t callbackLocalOptimum, SWIG_Callback17_t callbackAcceptDelta, SWIG_Callback18_t callbackAcceptNeighbor, SWIG_Callback19_t callbackAcceptUncheckedNeighbor, SWIG_Callback20_t callbackIsUncheckedSolutionLimitReached, SWIG_Callback21_t callbackPeriodicCheck, SWIG_Callback22_t callbackProgressPercent, SWIG_Callback23_t callbackAccept, SWIG_Callback24_t callbackInstall, SWIG_Callback25_t callbackCheck, SWIG_Callback26_t callbackInit, SWIG_Callback27_t callbackCopy, SWIG_Callback28_t callbackMakeClone) {
  swig_callbackToString = callbackToString;
  swig_callbackEnterSearch = callbackEnterSearch;
  swig_callbackRestartSearch = callbackRestartSearch;
  swig_callbackExitSearch = callbackExitSearch;
  swig_callbackBeginNextDecision = callbackBeginNextDecision;
  swig_callbackEndNextDecision = callbackEndNextDecision;
  swig_callbackApplyDecision = callbackApplyDecision;
  swig_callbackRefuteDecision = callbackRefuteDecision;
  swig_callbackAfterDecision = callbackAfterDecision;
  swig_callbackBeginFail = callbackBeginFail;
  swig_callbackEndFail = callbackEndFail;
  swig_callbackBeginInitialPropagation = callbackBeginInitialPropagation;
  swig_callbackEndInitialPropagation = callbackEndInitialPropagation;
  swig_callbackAcceptSolution = callbackAcceptSolution;
  swig_callbackAtSolution = callbackAtSolution;
  swig_callbackNoMoreSolutions = callbackNoMoreSolutions;
  swig_callbackLocalOptimum = callbackLocalOptimum;
  swig_callbackAcceptDelta = callbackAcceptDelta;
  swig_callbackAcceptNeighbor = callbackAcceptNeighbor;
  swig_callbackAcceptUncheckedNeighbor = callbackAcceptUncheckedNeighbor;
  swig_callbackIsUncheckedSolutionLimitReached = callbackIsUncheckedSolutionLimitReached;
  swig_callbackPeriodicCheck = callbackPeriodicCheck;
  swig_callbackProgressPercent = callbackProgressPercent;
  swig_callbackAccept = callbackAccept;
  swig_callbackInstall = callbackInstall;
  swig_callbackCheck = callbackCheck;
  swig_callbackInit = callbackInit;
  swig_callbackCopy = callbackCopy;
  swig_callbackMakeClone = callbackMakeClone;
}
 
void SwigDirector_RegularLimit::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackEnterSearch = 0;
  swig_callbackRestartSearch = 0;
  swig_callbackExitSearch = 0;
  swig_callbackBeginNextDecision = 0;
  swig_callbackEndNextDecision = 0;
  swig_callbackApplyDecision = 0;
  swig_callbackRefuteDecision = 0;
  swig_callbackAfterDecision = 0;
  swig_callbackBeginFail = 0;
  swig_callbackEndFail = 0;
  swig_callbackBeginInitialPropagation = 0;
  swig_callbackEndInitialPropagation = 0;
  swig_callbackAcceptSolution = 0;
  swig_callbackAtSolution = 0;
  swig_callbackNoMoreSolutions = 0;
  swig_callbackLocalOptimum = 0;
  swig_callbackAcceptDelta = 0;
  swig_callbackAcceptNeighbor = 0;
  swig_callbackAcceptUncheckedNeighbor = 0;
  swig_callbackIsUncheckedSolutionLimitReached = 0;
  swig_callbackPeriodicCheck = 0;
  swig_callbackProgressPercent = 0;
  swig_callbackAccept = 0;
  swig_callbackInstall = 0;
  swig_callbackCheck = 0;
  swig_callbackInit = 0;
  swig_callbackCopy = 0;
  swig_callbackMakeClone = 0;
}
 
SwigDirector_LocalSearchOperator::SwigDirector_LocalSearchOperator() : operations_research::LocalSearchOperator(), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_LocalSearchOperator::~SwigDirector_LocalSearchOperator() {
  
}
 
 
std::string SwigDirector_LocalSearchOperator::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
bool SwigDirector_LocalSearchOperator::MakeNextNeighbor(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackMakeNextNeighbor) {
    Swig::DirectorPureVirtualException::raise("operations_research::LocalSearchOperator::MakeNextNeighbor");
    return c_result;
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jresult = (unsigned int) swig_callbackMakeNextNeighbor(jdelta, jdeltadelta);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_LocalSearchOperator::Start(operations_research::Assignment const *assignment) {
  void * jassignment = 0 ;
  
  if (!swig_callbackStart) {
    Swig::DirectorPureVirtualException::raise("operations_research::LocalSearchOperator::Start");
    return;
  } else {
    jassignment = (void *) assignment; 
    swig_callbackStart(jassignment);
  }
}
 
void SwigDirector_LocalSearchOperator::Reset() {
  if (!swig_callbackReset) {
    operations_research::LocalSearchOperator::Reset();
    return;
  } else {
    swig_callbackReset();
  }
}
 
bool SwigDirector_LocalSearchOperator::HasFragments() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHasFragments) {
    return operations_research::LocalSearchOperator::HasFragments();
  } else {
    jresult = (unsigned int) swig_callbackHasFragments();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_LocalSearchOperator::HoldsDelta() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHoldsDelta) {
    return operations_research::LocalSearchOperator::HoldsDelta();
  } else {
    jresult = (unsigned int) swig_callbackHoldsDelta();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_LocalSearchOperator::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackMakeNextNeighbor, SWIG_Callback2_t callbackStart, SWIG_Callback3_t callbackReset, SWIG_Callback4_t callbackHasFragments, SWIG_Callback5_t callbackHoldsDelta) {
  swig_callbackToString = callbackToString;
  swig_callbackMakeNextNeighbor = callbackMakeNextNeighbor;
  swig_callbackStart = callbackStart;
  swig_callbackReset = callbackReset;
  swig_callbackHasFragments = callbackHasFragments;
  swig_callbackHoldsDelta = callbackHoldsDelta;
}
 
void SwigDirector_LocalSearchOperator::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackMakeNextNeighbor = 0;
  swig_callbackStart = 0;
  swig_callbackReset = 0;
  swig_callbackHasFragments = 0;
  swig_callbackHoldsDelta = 0;
}
 
SwigDirector_IntVarLocalSearchOperator::SwigDirector_IntVarLocalSearchOperator() : operations_research::IntVarLocalSearchOperator(), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_IntVarLocalSearchOperator::SwigDirector_IntVarLocalSearchOperator(std::vector< operations_research::IntVar * > const &vars, bool keep_inverse_values) : operations_research::IntVarLocalSearchOperator(vars, keep_inverse_values), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_IntVarLocalSearchOperator::~SwigDirector_IntVarLocalSearchOperator() {
  
}
 
 
std::string SwigDirector_IntVarLocalSearchOperator::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
bool SwigDirector_IntVarLocalSearchOperator::MakeNextNeighbor(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  return operations_research::IntVarLocalSearchOperator::MakeNextNeighbor(delta,deltadelta);
}
 
void SwigDirector_IntVarLocalSearchOperator::Start(operations_research::Assignment const *assignment) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::Start(assignment);
}
 
void SwigDirector_IntVarLocalSearchOperator::Reset() {
  if (!swig_callbackReset) {
    operations_research::LocalSearchOperator::Reset();
    return;
  } else {
    swig_callbackReset();
  }
}
 
bool SwigDirector_IntVarLocalSearchOperator::HasFragments() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHasFragments) {
    return operations_research::LocalSearchOperator::HasFragments();
  } else {
    jresult = (unsigned int) swig_callbackHasFragments();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_IntVarLocalSearchOperator::HoldsDelta() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHoldsDelta) {
    return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::HoldsDelta();
  } else {
    jresult = (unsigned int) swig_callbackHoldsDelta();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_IntVarLocalSearchOperator::IsIncremental() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsIncremental) {
    return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::IsIncremental();
  } else {
    jresult = (unsigned int) swig_callbackIsIncremental();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_IntVarLocalSearchOperator::SkipUnchanged(int index) const {
  return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::SkipUnchanged(index);
}
 
void SwigDirector_IntVarLocalSearchOperator::OnStart() {
  if (!swig_callbackOnStart) {
    operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::OnStart();
    return;
  } else {
    swig_callbackOnStart();
  }
}
 
bool SwigDirector_IntVarLocalSearchOperator::MakeOneNeighbor() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackMakeOneNeighbor) {
    return operations_research::IntVarLocalSearchOperator::MakeOneNeighbor();
  } else {
    jresult = (unsigned int) swig_callbackMakeOneNeighbor();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_IntVarLocalSearchOperator::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackReset, SWIG_Callback2_t callbackHasFragments, SWIG_Callback3_t callbackHoldsDelta, SWIG_Callback4_t callbackIsIncremental, SWIG_Callback5_t callbackOnStart, SWIG_Callback6_t callbackMakeOneNeighbor) {
  swig_callbackToString = callbackToString;
  swig_callbackReset = callbackReset;
  swig_callbackHasFragments = callbackHasFragments;
  swig_callbackHoldsDelta = callbackHoldsDelta;
  swig_callbackIsIncremental = callbackIsIncremental;
  swig_callbackOnStart = callbackOnStart;
  swig_callbackMakeOneNeighbor = callbackMakeOneNeighbor;
}
 
void SwigDirector_IntVarLocalSearchOperator::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackReset = 0;
  swig_callbackHasFragments = 0;
  swig_callbackHoldsDelta = 0;
  swig_callbackIsIncremental = 0;
  swig_callbackOnStart = 0;
  swig_callbackMakeOneNeighbor = 0;
}
 
SwigDirector_SequenceVarLocalSearchOperator::SwigDirector_SequenceVarLocalSearchOperator() : operations_research::SequenceVarLocalSearchOperator(), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_SequenceVarLocalSearchOperator::SwigDirector_SequenceVarLocalSearchOperator(std::vector< operations_research::SequenceVar * > const &vars) : operations_research::SequenceVarLocalSearchOperator(vars), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_SequenceVarLocalSearchOperator::~SwigDirector_SequenceVarLocalSearchOperator() {
  
}
 
 
std::string SwigDirector_SequenceVarLocalSearchOperator::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
bool SwigDirector_SequenceVarLocalSearchOperator::MakeNextNeighbor(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackMakeNextNeighbor) {
    Swig::DirectorPureVirtualException::raise("operations_research::SequenceVarLocalSearchOperator::MakeNextNeighbor");
    return c_result;
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jresult = (unsigned int) swig_callbackMakeNextNeighbor(jdelta, jdeltadelta);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_SequenceVarLocalSearchOperator::Start(operations_research::Assignment const *assignment) {
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler >::Start(assignment);
}
 
void SwigDirector_SequenceVarLocalSearchOperator::Reset() {
  if (!swig_callbackReset) {
    operations_research::LocalSearchOperator::Reset();
    return;
  } else {
    swig_callbackReset();
  }
}
 
bool SwigDirector_SequenceVarLocalSearchOperator::HasFragments() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHasFragments) {
    return operations_research::LocalSearchOperator::HasFragments();
  } else {
    jresult = (unsigned int) swig_callbackHasFragments();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SequenceVarLocalSearchOperator::HoldsDelta() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHoldsDelta) {
    return operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler >::HoldsDelta();
  } else {
    jresult = (unsigned int) swig_callbackHoldsDelta();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SequenceVarLocalSearchOperator::IsIncremental() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsIncremental) {
    return operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler >::IsIncremental();
  } else {
    jresult = (unsigned int) swig_callbackIsIncremental();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_SequenceVarLocalSearchOperator::SkipUnchanged(int index) const {
  return operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler >::SkipUnchanged(index);
}
 
void SwigDirector_SequenceVarLocalSearchOperator::OnStart() {
  if (!swig_callbackOnStart) {
    operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler >::OnStart();
    return;
  } else {
    swig_callbackOnStart();
  }
}
 
void SwigDirector_SequenceVarLocalSearchOperator::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackMakeNextNeighbor, SWIG_Callback2_t callbackReset, SWIG_Callback3_t callbackHasFragments, SWIG_Callback4_t callbackHoldsDelta, SWIG_Callback5_t callbackIsIncremental, SWIG_Callback6_t callbackOnStart) {
  swig_callbackToString = callbackToString;
  swig_callbackMakeNextNeighbor = callbackMakeNextNeighbor;
  swig_callbackReset = callbackReset;
  swig_callbackHasFragments = callbackHasFragments;
  swig_callbackHoldsDelta = callbackHoldsDelta;
  swig_callbackIsIncremental = callbackIsIncremental;
  swig_callbackOnStart = callbackOnStart;
}
 
void SwigDirector_SequenceVarLocalSearchOperator::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackMakeNextNeighbor = 0;
  swig_callbackReset = 0;
  swig_callbackHasFragments = 0;
  swig_callbackHoldsDelta = 0;
  swig_callbackIsIncremental = 0;
  swig_callbackOnStart = 0;
}
 
SwigDirector_BaseLns::SwigDirector_BaseLns(std::vector< operations_research::IntVar * > const &vars) : operations_research::BaseLns(vars), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_BaseLns::~SwigDirector_BaseLns() {
  
}
 
 
std::string SwigDirector_BaseLns::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
bool SwigDirector_BaseLns::MakeNextNeighbor(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  return operations_research::IntVarLocalSearchOperator::MakeNextNeighbor(delta,deltadelta);
}
 
void SwigDirector_BaseLns::Start(operations_research::Assignment const *assignment) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::Start(assignment);
}
 
void SwigDirector_BaseLns::Reset() {
  if (!swig_callbackReset) {
    operations_research::LocalSearchOperator::Reset();
    return;
  } else {
    swig_callbackReset();
  }
}
 
bool SwigDirector_BaseLns::HasFragments() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHasFragments) {
    return operations_research::BaseLns::HasFragments();
  } else {
    jresult = (unsigned int) swig_callbackHasFragments();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_BaseLns::HoldsDelta() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHoldsDelta) {
    return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::HoldsDelta();
  } else {
    jresult = (unsigned int) swig_callbackHoldsDelta();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_BaseLns::IsIncremental() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsIncremental) {
    return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::IsIncremental();
  } else {
    jresult = (unsigned int) swig_callbackIsIncremental();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_BaseLns::InitFragments() {
  if (!swig_callbackInitFragments) {
    operations_research::BaseLns::InitFragments();
    return;
  } else {
    swig_callbackInitFragments();
  }
}
 
bool SwigDirector_BaseLns::NextFragment() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackNextFragment) {
    Swig::DirectorPureVirtualException::raise("operations_research::BaseLns::NextFragment");
    return c_result;
  } else {
    jresult = (unsigned int) swig_callbackNextFragment();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_BaseLns::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackReset, SWIG_Callback2_t callbackHasFragments, SWIG_Callback3_t callbackHoldsDelta, SWIG_Callback4_t callbackIsIncremental, SWIG_Callback5_t callbackInitFragments, SWIG_Callback6_t callbackNextFragment) {
  swig_callbackToString = callbackToString;
  swig_callbackReset = callbackReset;
  swig_callbackHasFragments = callbackHasFragments;
  swig_callbackHoldsDelta = callbackHoldsDelta;
  swig_callbackIsIncremental = callbackIsIncremental;
  swig_callbackInitFragments = callbackInitFragments;
  swig_callbackNextFragment = callbackNextFragment;
}
 
void SwigDirector_BaseLns::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackReset = 0;
  swig_callbackHasFragments = 0;
  swig_callbackHoldsDelta = 0;
  swig_callbackIsIncremental = 0;
  swig_callbackInitFragments = 0;
  swig_callbackNextFragment = 0;
}
 
SwigDirector_ChangeValue::SwigDirector_ChangeValue(std::vector< operations_research::IntVar * > const &vars) : operations_research::ChangeValue(vars), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_ChangeValue::~SwigDirector_ChangeValue() {
  
}
 
 
std::string SwigDirector_ChangeValue::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
bool SwigDirector_ChangeValue::MakeNextNeighbor(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  return operations_research::IntVarLocalSearchOperator::MakeNextNeighbor(delta,deltadelta);
}
 
void SwigDirector_ChangeValue::Start(operations_research::Assignment const *assignment) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::Start(assignment);
}
 
void SwigDirector_ChangeValue::Reset() {
  if (!swig_callbackReset) {
    operations_research::LocalSearchOperator::Reset();
    return;
  } else {
    swig_callbackReset();
  }
}
 
bool SwigDirector_ChangeValue::HasFragments() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHasFragments) {
    return operations_research::LocalSearchOperator::HasFragments();
  } else {
    jresult = (unsigned int) swig_callbackHasFragments();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_ChangeValue::HoldsDelta() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHoldsDelta) {
    return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::HoldsDelta();
  } else {
    jresult = (unsigned int) swig_callbackHoldsDelta();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_ChangeValue::IsIncremental() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsIncremental) {
    return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::IsIncremental();
  } else {
    jresult = (unsigned int) swig_callbackIsIncremental();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_ChangeValue::SkipUnchanged(int index) const {
  return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::SkipUnchanged(index);
}
 
void SwigDirector_ChangeValue::OnStart() {
  if (!swig_callbackOnStart) {
    operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::OnStart();
    return;
  } else {
    swig_callbackOnStart();
  }
}
 
bool SwigDirector_ChangeValue::MakeOneNeighbor() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackMakeOneNeighbor) {
    return operations_research::ChangeValue::MakeOneNeighbor();
  } else {
    jresult = (unsigned int) swig_callbackMakeOneNeighbor();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
int64_t SwigDirector_ChangeValue::ModifyValue(int64_t index, int64_t value) {
  int64_t c_result = SwigValueInit< int64_t >() ;
  long long jresult = 0 ;
  long long jindex  ;
  long long jvalue  ;
  
  if (!swig_callbackModifyValue) {
    Swig::DirectorPureVirtualException::raise("operations_research::ChangeValue::ModifyValue");
    return c_result;
  } else {
    jindex = index;
    jvalue = value;
    jresult = (long long) swig_callbackModifyValue(jindex, jvalue);
    c_result = (int64_t)jresult; 
  }
  return c_result;
}
 
void SwigDirector_ChangeValue::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackReset, SWIG_Callback2_t callbackHasFragments, SWIG_Callback3_t callbackHoldsDelta, SWIG_Callback4_t callbackIsIncremental, SWIG_Callback5_t callbackOnStart, SWIG_Callback6_t callbackMakeOneNeighbor, SWIG_Callback7_t callbackModifyValue) {
  swig_callbackToString = callbackToString;
  swig_callbackReset = callbackReset;
  swig_callbackHasFragments = callbackHasFragments;
  swig_callbackHoldsDelta = callbackHoldsDelta;
  swig_callbackIsIncremental = callbackIsIncremental;
  swig_callbackOnStart = callbackOnStart;
  swig_callbackMakeOneNeighbor = callbackMakeOneNeighbor;
  swig_callbackModifyValue = callbackModifyValue;
}
 
void SwigDirector_ChangeValue::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackReset = 0;
  swig_callbackHasFragments = 0;
  swig_callbackHoldsDelta = 0;
  swig_callbackIsIncremental = 0;
  swig_callbackOnStart = 0;
  swig_callbackMakeOneNeighbor = 0;
  swig_callbackModifyValue = 0;
}
 
SwigDirector_PathOperator::~SwigDirector_PathOperator() {
  
}
 
 
std::string SwigDirector_PathOperator::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
bool SwigDirector_PathOperator::MakeNextNeighbor(operations_research::Assignment *delta, operations_research::Assignment *deltadelta) {
  return operations_research::IntVarLocalSearchOperator::MakeNextNeighbor(delta,deltadelta);
}
 
void SwigDirector_PathOperator::Start(operations_research::Assignment const *assignment) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::Start(assignment);
}
 
void SwigDirector_PathOperator::Reset() {
  if (!swig_callbackReset) {
    operations_research::PathOperator::Reset();
    return;
  } else {
    swig_callbackReset();
  }
}
 
bool SwigDirector_PathOperator::HasFragments() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHasFragments) {
    return operations_research::LocalSearchOperator::HasFragments();
  } else {
    jresult = (unsigned int) swig_callbackHasFragments();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_PathOperator::HoldsDelta() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackHoldsDelta) {
    return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::HoldsDelta();
  } else {
    jresult = (unsigned int) swig_callbackHoldsDelta();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_PathOperator::IsIncremental() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsIncremental) {
    return operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::IsIncremental();
  } else {
    jresult = (unsigned int) swig_callbackIsIncremental();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_PathOperator::SkipUnchanged(int index) const {
  return operations_research::PathOperator::SkipUnchanged(index);
}
 
void SwigDirector_PathOperator::OnStart() {
  if (!swig_callbackOnStart) {
    operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler >::OnStart();
    return;
  } else {
    swig_callbackOnStart();
  }
}
 
bool SwigDirector_PathOperator::MakeOneNeighbor() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackMakeOneNeighbor) {
    return operations_research::PathOperator::MakeOneNeighbor();
  } else {
    jresult = (unsigned int) swig_callbackMakeOneNeighbor();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_PathOperator::MakeNeighbor() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackMakeNeighbor) {
    Swig::DirectorPureVirtualException::raise("operations_research::PathOperator::MakeNeighbor");
    return c_result;
  } else {
    jresult = (unsigned int) swig_callbackMakeNeighbor();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_PathOperator::OnNodeInitialization() {
  if (!swig_callbackOnNodeInitialization) {
    operations_research::PathOperator::OnNodeInitialization();
    return;
  } else {
    swig_callbackOnNodeInitialization();
  }
}
 
bool SwigDirector_PathOperator::RestartAtPathStartOnSynchronize() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackRestartAtPathStartOnSynchronize) {
    return operations_research::PathOperator::RestartAtPathStartOnSynchronize();
  } else {
    jresult = (unsigned int) swig_callbackRestartAtPathStartOnSynchronize();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_PathOperator::OnSamePathAsPreviousBase(int64_t base_index) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  long long jbase_index  ;
  
  if (!swig_callbackOnSamePathAsPreviousBase) {
    return operations_research::PathOperator::OnSamePathAsPreviousBase(base_index);
  } else {
    jbase_index = base_index;
    jresult = (unsigned int) swig_callbackOnSamePathAsPreviousBase(jbase_index);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
int64_t SwigDirector_PathOperator::GetBaseNodeRestartPosition(int base_index) {
  int64_t c_result = SwigValueInit< int64_t >() ;
  long long jresult = 0 ;
  int jbase_index  ;
  
  if (!swig_callbackGetBaseNodeRestartPosition) {
    return operations_research::PathOperator::GetBaseNodeRestartPosition(base_index);
  } else {
    jbase_index = base_index;
    jresult = (long long) swig_callbackGetBaseNodeRestartPosition(jbase_index);
    c_result = (int64_t)jresult; 
  }
  return c_result;
}
 
void SwigDirector_PathOperator::SetNextBaseToIncrement(int64_t base_index) {
  long long jbase_index  ;
  
  if (!swig_callbackSetNextBaseToIncrement) {
    operations_research::PathOperator::SetNextBaseToIncrement(base_index);
    return;
  } else {
    jbase_index = base_index;
    swig_callbackSetNextBaseToIncrement(jbase_index);
  }
}
 
bool SwigDirector_PathOperator::ConsiderAlternatives(int64_t base_index) const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  long long jbase_index  ;
  
  if (!swig_callbackConsiderAlternatives) {
    return operations_research::PathOperator::ConsiderAlternatives(base_index);
  } else {
    jbase_index = base_index;
    jresult = (unsigned int) swig_callbackConsiderAlternatives(jbase_index);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_PathOperator::InitPosition() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackInitPosition) {
    return operations_research::PathOperator::InitPosition();
  } else {
    jresult = (unsigned int) swig_callbackInitPosition();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_PathOperator::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackReset, SWIG_Callback2_t callbackHasFragments, SWIG_Callback3_t callbackHoldsDelta, SWIG_Callback4_t callbackIsIncremental, SWIG_Callback5_t callbackOnStart, SWIG_Callback6_t callbackMakeOneNeighbor, SWIG_Callback7_t callbackMakeNeighbor, SWIG_Callback8_t callbackOnNodeInitialization, SWIG_Callback9_t callbackRestartAtPathStartOnSynchronize, SWIG_Callback10_t callbackOnSamePathAsPreviousBase, SWIG_Callback11_t callbackGetBaseNodeRestartPosition, SWIG_Callback12_t callbackSetNextBaseToIncrement, SWIG_Callback13_t callbackConsiderAlternatives, SWIG_Callback14_t callbackInitPosition) {
  swig_callbackToString = callbackToString;
  swig_callbackReset = callbackReset;
  swig_callbackHasFragments = callbackHasFragments;
  swig_callbackHoldsDelta = callbackHoldsDelta;
  swig_callbackIsIncremental = callbackIsIncremental;
  swig_callbackOnStart = callbackOnStart;
  swig_callbackMakeOneNeighbor = callbackMakeOneNeighbor;
  swig_callbackMakeNeighbor = callbackMakeNeighbor;
  swig_callbackOnNodeInitialization = callbackOnNodeInitialization;
  swig_callbackRestartAtPathStartOnSynchronize = callbackRestartAtPathStartOnSynchronize;
  swig_callbackOnSamePathAsPreviousBase = callbackOnSamePathAsPreviousBase;
  swig_callbackGetBaseNodeRestartPosition = callbackGetBaseNodeRestartPosition;
  swig_callbackSetNextBaseToIncrement = callbackSetNextBaseToIncrement;
  swig_callbackConsiderAlternatives = callbackConsiderAlternatives;
  swig_callbackInitPosition = callbackInitPosition;
}
 
void SwigDirector_PathOperator::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackReset = 0;
  swig_callbackHasFragments = 0;
  swig_callbackHoldsDelta = 0;
  swig_callbackIsIncremental = 0;
  swig_callbackOnStart = 0;
  swig_callbackMakeOneNeighbor = 0;
  swig_callbackMakeNeighbor = 0;
  swig_callbackOnNodeInitialization = 0;
  swig_callbackRestartAtPathStartOnSynchronize = 0;
  swig_callbackOnSamePathAsPreviousBase = 0;
  swig_callbackGetBaseNodeRestartPosition = 0;
  swig_callbackSetNextBaseToIncrement = 0;
  swig_callbackConsiderAlternatives = 0;
  swig_callbackInitPosition = 0;
}
 
SwigDirector_LocalSearchFilter::SwigDirector_LocalSearchFilter() : operations_research::LocalSearchFilter(), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_LocalSearchFilter::~SwigDirector_LocalSearchFilter() {
  
}
 
 
std::string SwigDirector_LocalSearchFilter::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_LocalSearchFilter::Relax(operations_research::Assignment const *delta, operations_research::Assignment const *deltadelta) {
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackRelax) {
    operations_research::LocalSearchFilter::Relax(delta,deltadelta);
    return;
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    swig_callbackRelax(jdelta, jdeltadelta);
  }
}
 
void SwigDirector_LocalSearchFilter::Commit(operations_research::Assignment const *delta, operations_research::Assignment const *deltadelta) {
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackCommit) {
    operations_research::LocalSearchFilter::Commit(delta,deltadelta);
    return;
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    swig_callbackCommit(jdelta, jdeltadelta);
  }
}
 
bool SwigDirector_LocalSearchFilter::Accept(operations_research::Assignment const *delta, operations_research::Assignment const *deltadelta, int64_t objective_min, int64_t objective_max) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  long long jobjective_min  ;
  long long jobjective_max  ;
  
  if (!swig_callbackAccept) {
    Swig::DirectorPureVirtualException::raise("operations_research::LocalSearchFilter::Accept");
    return c_result;
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jobjective_min = objective_min;
    jobjective_max = objective_max;
    jresult = (unsigned int) swig_callbackAccept(jdelta, jdeltadelta, jobjective_min, jobjective_max);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_LocalSearchFilter::IsIncremental() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsIncremental) {
    return operations_research::LocalSearchFilter::IsIncremental();
  } else {
    jresult = (unsigned int) swig_callbackIsIncremental();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_LocalSearchFilter::Synchronize(operations_research::Assignment const *assignment, operations_research::Assignment const *delta) {
  void * jassignment = 0 ;
  void * jdelta = 0 ;
  
  if (!swig_callbackSynchronize) {
    Swig::DirectorPureVirtualException::raise("operations_research::LocalSearchFilter::Synchronize");
    return;
  } else {
    jassignment = (void *) assignment; 
    jdelta = (void *) delta; 
    swig_callbackSynchronize(jassignment, jdelta);
  }
}
 
void SwigDirector_LocalSearchFilter::Revert() {
  if (!swig_callbackRevert) {
    operations_research::LocalSearchFilter::Revert();
    return;
  } else {
    swig_callbackRevert();
  }
}
 
void SwigDirector_LocalSearchFilter::Reset() {
  if (!swig_callbackReset) {
    operations_research::LocalSearchFilter::Reset();
    return;
  } else {
    swig_callbackReset();
  }
}
 
int64_t SwigDirector_LocalSearchFilter::GetSynchronizedObjectiveValue() const {
  int64_t c_result = SwigValueInit< int64_t >() ;
  long long jresult = 0 ;
  
  if (!swig_callbackGetSynchronizedObjectiveValue) {
    return operations_research::LocalSearchFilter::GetSynchronizedObjectiveValue();
  } else {
    jresult = (long long) swig_callbackGetSynchronizedObjectiveValue();
    c_result = (int64_t)jresult; 
  }
  return c_result;
}
 
int64_t SwigDirector_LocalSearchFilter::GetAcceptedObjectiveValue() const {
  int64_t c_result = SwigValueInit< int64_t >() ;
  long long jresult = 0 ;
  
  if (!swig_callbackGetAcceptedObjectiveValue) {
    return operations_research::LocalSearchFilter::GetAcceptedObjectiveValue();
  } else {
    jresult = (long long) swig_callbackGetAcceptedObjectiveValue();
    c_result = (int64_t)jresult; 
  }
  return c_result;
}
 
void SwigDirector_LocalSearchFilter::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackRelax, SWIG_Callback2_t callbackCommit, SWIG_Callback3_t callbackAccept, SWIG_Callback4_t callbackIsIncremental, SWIG_Callback5_t callbackSynchronize, SWIG_Callback6_t callbackRevert, SWIG_Callback7_t callbackReset, SWIG_Callback8_t callbackGetSynchronizedObjectiveValue, SWIG_Callback9_t callbackGetAcceptedObjectiveValue) {
  swig_callbackToString = callbackToString;
  swig_callbackRelax = callbackRelax;
  swig_callbackCommit = callbackCommit;
  swig_callbackAccept = callbackAccept;
  swig_callbackIsIncremental = callbackIsIncremental;
  swig_callbackSynchronize = callbackSynchronize;
  swig_callbackRevert = callbackRevert;
  swig_callbackReset = callbackReset;
  swig_callbackGetSynchronizedObjectiveValue = callbackGetSynchronizedObjectiveValue;
  swig_callbackGetAcceptedObjectiveValue = callbackGetAcceptedObjectiveValue;
}
 
void SwigDirector_LocalSearchFilter::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackRelax = 0;
  swig_callbackCommit = 0;
  swig_callbackAccept = 0;
  swig_callbackIsIncremental = 0;
  swig_callbackSynchronize = 0;
  swig_callbackRevert = 0;
  swig_callbackReset = 0;
  swig_callbackGetSynchronizedObjectiveValue = 0;
  swig_callbackGetAcceptedObjectiveValue = 0;
}
 
SwigDirector_LocalSearchFilterManager::SwigDirector_LocalSearchFilterManager(std::vector< operations_research::LocalSearchFilterManager::FilterEvent > filter_events) : operations_research::LocalSearchFilterManager(filter_events), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_LocalSearchFilterManager::SwigDirector_LocalSearchFilterManager(std::vector< operations_research::LocalSearchFilter * > filters) : operations_research::LocalSearchFilterManager(filters), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_LocalSearchFilterManager::~SwigDirector_LocalSearchFilterManager() {
  
}
 
 
std::string SwigDirector_LocalSearchFilterManager::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::LocalSearchFilterManager::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_LocalSearchFilterManager::swig_connect_director(SWIG_Callback0_t callbackToString) {
  swig_callbackToString = callbackToString;
}
 
void SwigDirector_LocalSearchFilterManager::swig_init_callbacks() {
  swig_callbackToString = 0;
}
 
SwigDirector_IntVarLocalSearchFilter::SwigDirector_IntVarLocalSearchFilter(std::vector< operations_research::IntVar * > const &vars) : operations_research::IntVarLocalSearchFilter(vars), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_IntVarLocalSearchFilter::~SwigDirector_IntVarLocalSearchFilter() {
  
}
 
 
std::string SwigDirector_IntVarLocalSearchFilter::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_IntVarLocalSearchFilter::Relax(operations_research::Assignment const *delta, operations_research::Assignment const *deltadelta) {
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackRelax) {
    operations_research::LocalSearchFilter::Relax(delta,deltadelta);
    return;
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    swig_callbackRelax(jdelta, jdeltadelta);
  }
}
 
void SwigDirector_IntVarLocalSearchFilter::Commit(operations_research::Assignment const *delta, operations_research::Assignment const *deltadelta) {
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  
  if (!swig_callbackCommit) {
    operations_research::LocalSearchFilter::Commit(delta,deltadelta);
    return;
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    swig_callbackCommit(jdelta, jdeltadelta);
  }
}
 
bool SwigDirector_IntVarLocalSearchFilter::Accept(operations_research::Assignment const *delta, operations_research::Assignment const *deltadelta, int64_t objective_min, int64_t objective_max) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  void * jdelta = 0 ;
  void * jdeltadelta = 0 ;
  long long jobjective_min  ;
  long long jobjective_max  ;
  
  if (!swig_callbackAccept) {
    Swig::DirectorPureVirtualException::raise("operations_research::IntVarLocalSearchFilter::Accept");
    return c_result;
  } else {
    jdelta = (void *) delta; 
    jdeltadelta = (void *) deltadelta; 
    jobjective_min = objective_min;
    jobjective_max = objective_max;
    jresult = (unsigned int) swig_callbackAccept(jdelta, jdeltadelta, jobjective_min, jobjective_max);
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
bool SwigDirector_IntVarLocalSearchFilter::IsIncremental() const {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackIsIncremental) {
    return operations_research::LocalSearchFilter::IsIncremental();
  } else {
    jresult = (unsigned int) swig_callbackIsIncremental();
    c_result = jresult ? true : false; 
  }
  return c_result;
}
 
void SwigDirector_IntVarLocalSearchFilter::Revert() {
  if (!swig_callbackRevert) {
    operations_research::LocalSearchFilter::Revert();
    return;
  } else {
    swig_callbackRevert();
  }
}
 
void SwigDirector_IntVarLocalSearchFilter::Reset() {
  if (!swig_callbackReset) {
    operations_research::LocalSearchFilter::Reset();
    return;
  } else {
    swig_callbackReset();
  }
}
 
int64_t SwigDirector_IntVarLocalSearchFilter::GetSynchronizedObjectiveValue() const {
  int64_t c_result = SwigValueInit< int64_t >() ;
  long long jresult = 0 ;
  
  if (!swig_callbackGetSynchronizedObjectiveValue) {
    return operations_research::LocalSearchFilter::GetSynchronizedObjectiveValue();
  } else {
    jresult = (long long) swig_callbackGetSynchronizedObjectiveValue();
    c_result = (int64_t)jresult; 
  }
  return c_result;
}
 
int64_t SwigDirector_IntVarLocalSearchFilter::GetAcceptedObjectiveValue() const {
  int64_t c_result = SwigValueInit< int64_t >() ;
  long long jresult = 0 ;
  
  if (!swig_callbackGetAcceptedObjectiveValue) {
    return operations_research::LocalSearchFilter::GetAcceptedObjectiveValue();
  } else {
    jresult = (long long) swig_callbackGetAcceptedObjectiveValue();
    c_result = (int64_t)jresult; 
  }
  return c_result;
}
 
void SwigDirector_IntVarLocalSearchFilter::OnSynchronize(operations_research::Assignment const *delta) {
  void * jdelta = 0 ;
  
  if (!swig_callbackOnSynchronize) {
    operations_research::IntVarLocalSearchFilter::OnSynchronize(delta);
    return;
  } else {
    jdelta = (void *) delta; 
    swig_callbackOnSynchronize(jdelta);
  }
}
 
void SwigDirector_IntVarLocalSearchFilter::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackRelax, SWIG_Callback2_t callbackCommit, SWIG_Callback3_t callbackAccept, SWIG_Callback4_t callbackIsIncremental, SWIG_Callback5_t callbackRevert, SWIG_Callback6_t callbackReset, SWIG_Callback7_t callbackGetSynchronizedObjectiveValue, SWIG_Callback8_t callbackGetAcceptedObjectiveValue, SWIG_Callback9_t callbackOnSynchronize) {
  swig_callbackToString = callbackToString;
  swig_callbackRelax = callbackRelax;
  swig_callbackCommit = callbackCommit;
  swig_callbackAccept = callbackAccept;
  swig_callbackIsIncremental = callbackIsIncremental;
  swig_callbackRevert = callbackRevert;
  swig_callbackReset = callbackReset;
  swig_callbackGetSynchronizedObjectiveValue = callbackGetSynchronizedObjectiveValue;
  swig_callbackGetAcceptedObjectiveValue = callbackGetAcceptedObjectiveValue;
  swig_callbackOnSynchronize = callbackOnSynchronize;
}
 
void SwigDirector_IntVarLocalSearchFilter::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackRelax = 0;
  swig_callbackCommit = 0;
  swig_callbackAccept = 0;
  swig_callbackIsIncremental = 0;
  swig_callbackRevert = 0;
  swig_callbackReset = 0;
  swig_callbackGetSynchronizedObjectiveValue = 0;
  swig_callbackGetAcceptedObjectiveValue = 0;
  swig_callbackOnSynchronize = 0;
}
 
SwigDirector_SymmetryBreaker::SwigDirector_SymmetryBreaker() : operations_research::SymmetryBreaker(), Swig::Director() {
  swig_init_callbacks();
}
 
SwigDirector_SymmetryBreaker::~SwigDirector_SymmetryBreaker() {
  
}
 
 
std::string SwigDirector_SymmetryBreaker::DebugString() const {
  std::string c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackToString) {
    return operations_research::BaseObject::DebugString();
  } else {
    jresult = (char *) swig_callbackToString();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}
 
void SwigDirector_SymmetryBreaker::VisitSetVariableValue(operations_research::IntVar *const var, int64_t value) {
  void * jvar = 0 ;
  long long jvalue  ;
  
  if (!swig_callbackVisitSetVariableValue) {
    operations_research::DecisionVisitor::VisitSetVariableValue(var,value);
    return;
  } else {
    jvar = (void *) var; 
    jvalue = value;
    swig_callbackVisitSetVariableValue(jvar, jvalue);
  }
}
 
void SwigDirector_SymmetryBreaker::VisitSplitVariableDomain(operations_research::IntVar *const var, int64_t value, bool start_with_lower_half) {
  void * jvar = 0 ;
  long long jvalue  ;
  unsigned int jstart_with_lower_half  ;
  
  if (!swig_callbackVisitSplitVariableDomain) {
    operations_research::DecisionVisitor::VisitSplitVariableDomain(var,value,start_with_lower_half);
    return;
  } else {
    jvar = (void *) var; 
    jvalue = value;
    jstart_with_lower_half = start_with_lower_half;
    swig_callbackVisitSplitVariableDomain(jvar, jvalue, jstart_with_lower_half);
  }
}
 
void SwigDirector_SymmetryBreaker::VisitScheduleOrPostpone(operations_research::IntervalVar *const var, int64_t est) {
  void * jvar = 0 ;
  long long jest  ;
  
  if (!swig_callbackVisitScheduleOrPostpone) {
    operations_research::DecisionVisitor::VisitScheduleOrPostpone(var,est);
    return;
  } else {
    jvar = (void *) var; 
    jest = est;
    swig_callbackVisitScheduleOrPostpone(jvar, jest);
  }
}
 
void SwigDirector_SymmetryBreaker::VisitScheduleOrExpedite(operations_research::IntervalVar *const var, int64_t est) {
  void * jvar = 0 ;
  long long jest  ;
  
  if (!swig_callbackVisitScheduleOrExpedite) {
    operations_research::DecisionVisitor::VisitScheduleOrExpedite(var,est);
    return;
  } else {
    jvar = (void *) var; 
    jest = est;
    swig_callbackVisitScheduleOrExpedite(jvar, jest);
  }
}
 
void SwigDirector_SymmetryBreaker::VisitRankFirstInterval(operations_research::SequenceVar *const sequence, int index) {
  void * jsequence = 0 ;
  int jindex  ;
  
  if (!swig_callbackVisitRankFirstInterval) {
    operations_research::DecisionVisitor::VisitRankFirstInterval(sequence,index);
    return;
  } else {
    jsequence = (void *) sequence; 
    jindex = index;
    swig_callbackVisitRankFirstInterval(jsequence, jindex);
  }
}
 
void SwigDirector_SymmetryBreaker::VisitRankLastInterval(operations_research::SequenceVar *const sequence, int index) {
  void * jsequence = 0 ;
  int jindex  ;
  
  if (!swig_callbackVisitRankLastInterval) {
    operations_research::DecisionVisitor::VisitRankLastInterval(sequence,index);
    return;
  } else {
    jsequence = (void *) sequence; 
    jindex = index;
    swig_callbackVisitRankLastInterval(jsequence, jindex);
  }
}
 
void SwigDirector_SymmetryBreaker::VisitUnknownDecision() {
  if (!swig_callbackVisitUnknownDecision) {
    operations_research::DecisionVisitor::VisitUnknownDecision();
    return;
  } else {
    swig_callbackVisitUnknownDecision();
  }
}
 
void SwigDirector_SymmetryBreaker::swig_connect_director(SWIG_Callback0_t callbackToString, SWIG_Callback1_t callbackVisitSetVariableValue, SWIG_Callback2_t callbackVisitSplitVariableDomain, SWIG_Callback3_t callbackVisitScheduleOrPostpone, SWIG_Callback4_t callbackVisitScheduleOrExpedite, SWIG_Callback5_t callbackVisitRankFirstInterval, SWIG_Callback6_t callbackVisitRankLastInterval, SWIG_Callback7_t callbackVisitUnknownDecision) {
  swig_callbackToString = callbackToString;
  swig_callbackVisitSetVariableValue = callbackVisitSetVariableValue;
  swig_callbackVisitSplitVariableDomain = callbackVisitSplitVariableDomain;
  swig_callbackVisitScheduleOrPostpone = callbackVisitScheduleOrPostpone;
  swig_callbackVisitScheduleOrExpedite = callbackVisitScheduleOrExpedite;
  swig_callbackVisitRankFirstInterval = callbackVisitRankFirstInterval;
  swig_callbackVisitRankLastInterval = callbackVisitRankLastInterval;
  swig_callbackVisitUnknownDecision = callbackVisitUnknownDecision;
}
 
void SwigDirector_SymmetryBreaker::swig_init_callbacks() {
  swig_callbackToString = 0;
  swig_callbackVisitSetVariableValue = 0;
  swig_callbackVisitSplitVariableDomain = 0;
  swig_callbackVisitScheduleOrPostpone = 0;
  swig_callbackVisitScheduleOrExpedite = 0;
  swig_callbackVisitRankFirstInterval = 0;
  swig_callbackVisitRankLastInterval = 0;
  swig_callbackVisitUnknownDecision = 0;
}
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntBoolPair__SWIG_0___() {
  void * jresult ;
  std::pair< int,bool > *result = 0 ;
  
  result = (std::pair< int,bool > *)new std::pair< int,bool >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntBoolPair__SWIG_1___(int jarg1, unsigned int jarg2) {
  void * jresult ;
  int arg1 ;
  bool arg2 ;
  std::pair< int,bool > *result = 0 ;
  
  arg1 = (int)jarg1; 
  arg2 = jarg2 ? true : false; 
  result = (std::pair< int,bool > *)new std::pair< int,bool >(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntBoolPair__SWIG_2___(void * jarg1) {
  void * jresult ;
  std::pair< int,bool > *arg1 = 0 ;
  std::pair< int,bool > *result = 0 ;
  
  arg1 = (std::pair< int,bool > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< int,bool > const & type is null", 0);
    return 0;
  } 
  result = (std::pair< int,bool > *)new std::pair< int,bool >((std::pair< int,bool > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntBoolPair_first_set___(void * jarg1, int jarg2) {
  std::pair< int,bool > *arg1 = (std::pair< int,bool > *) 0 ;
  int arg2 ;
  
  arg1 = (std::pair< int,bool > *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->first = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntBoolPair_first_get___(void * jarg1) {
  int jresult ;
  std::pair< int,bool > *arg1 = (std::pair< int,bool > *) 0 ;
  int result;
  
  arg1 = (std::pair< int,bool > *)jarg1; 
  result = (int) ((arg1)->first);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntBoolPair_second_set___(void * jarg1, unsigned int jarg2) {
  std::pair< int,bool > *arg1 = (std::pair< int,bool > *) 0 ;
  bool arg2 ;
  
  arg1 = (std::pair< int,bool > *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->second = arg2;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntBoolPair_second_get___(void * jarg1) {
  unsigned int jresult ;
  std::pair< int,bool > *arg1 = (std::pair< int,bool > *) 0 ;
  bool result;
  
  arg1 = (std::pair< int,bool > *)jarg1; 
  result = (bool) ((arg1)->second);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntBoolPair___(void * jarg1) {
  std::pair< int,bool > *arg1 = (std::pair< int,bool > *) 0 ;
  
  arg1 = (std::pair< int,bool > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_Clear___(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_Add___(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  (arg1)->push_back((int const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int > *)jarg1; 
  result = ((std::vector< int > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int > *)jarg1; 
  result = ((std::vector< int > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVector__SWIG_0___() {
  void * jresult ;
  std::vector< int > *result = 0 ;
  
  result = (std::vector< int > *)new std::vector< int >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< int > *arg1 = 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< int > *)new_std_vector_Sl_int_Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_getitemcopy___(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (int)std_vector_Sl_int_Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_getitem___(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int >::value_type *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = *result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_setitem___(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_int_Sg__setitem(arg1,arg2,(int const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_int_Sg__AddRange(arg1,(std::vector< int > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< int > *)std_vector_Sl_int_Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_Insert___(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_int_Sg__Insert(arg1,arg2,(int const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_int_Sg__InsertRange(arg1,arg2,(std::vector< int > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_int_Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_int_Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_Repeat___(int jarg1, int jarg2) {
  void * jresult ;
  int *arg1 = 0 ;
  int arg2 ;
  int temp1 ;
  std::vector< int > *result = 0 ;
  
  temp1 = (int)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< int > *)std_vector_Sl_int_Sg__Repeat((int const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  std_vector_Sl_int_Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_int_Sg__SetRange(arg1,arg2,(std::vector< int > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_Contains___(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int_Sg__Contains(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_IndexOf___(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__IndexOf(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_LastIndexOf___(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__LastIndexOf(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVector_Remove___(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int_Sg__Remove(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVector___(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_Clear___(void * jarg1) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_Add___(void * jarg1, void * jarg2) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (std::vector< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  (arg1)->push_back((std::vector< int > const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type result;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  result = ((std::vector< std::vector< int > > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type result;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  result = ((std::vector< std::vector< int > > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (std::vector< std::vector< int > >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVectorVector__SWIG_0___() {
  void * jresult ;
  std::vector< std::vector< int > > *result = 0 ;
  
  result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVectorVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >((std::vector< std::vector< int > > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVectorVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::vector< int > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< std::vector< int > > *)new_std_vector_Sl_std_vector_Sl_int_Sg__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  std::vector< int > result;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = new std::vector< int >((const std::vector< int > &)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< int > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< std::vector< int > >::value_type *) &std_vector_Sl_std_vector_Sl_int_Sg__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__setitem(arg1,arg2,(std::vector< int > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  std::vector< std::vector< int > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (std::vector< std::vector< int > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_std_vector_Sl_int_Sg__Sg__AddRange(arg1,(std::vector< std::vector< int > > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< int > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< std::vector< int > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__Insert(arg1,arg2,(std::vector< int > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< int > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< int > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< int > > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< int > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< int > > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< std::vector< int > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg__Repeat((std::vector< int > const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVectorVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< int > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< int > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int > > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_int_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< int > > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVectorVector___(void * jarg1) {
  std::vector< std::vector< int > > *arg1 = (std::vector< std::vector< int > > *) 0 ;
  
  arg1 = (std::vector< std::vector< int > > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_Clear___(void * jarg1) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_Add___(void * jarg1, long long jarg2) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  long *arg2 = 0 ;
  long temp2 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  temp2 = (long)jarg2; 
  arg2 = &temp2; 
  (arg1)->push_back((long const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  std::vector< long >::size_type result;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  result = ((std::vector< int64_t > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  std::vector< long >::size_type result;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  result = ((std::vector< int64_t > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  std::vector< long >::size_type arg2 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (std::vector< long >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Int64Vector__SWIG_0___() {
  void * jresult ;
  std::vector< int64_t > *result = 0 ;
  
  result = (std::vector< int64_t > *)new std::vector< int64_t >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Int64Vector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< int64_t > *arg1 = 0 ;
  std::vector< int64_t > *result = 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< int64_t > *)new std::vector< int64_t >((std::vector< int64_t > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Int64Vector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< int64_t > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< int64_t > *)new_std_vector_Sl_int64_t_Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_getitemcopy___(void * jarg1, int jarg2) {
  long long jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  long result;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (long)std_vector_Sl_int64_t_Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_getitem___(void * jarg1, int jarg2) {
  long long jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  std::vector< long >::value_type *result = 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< long >::value_type *) &std_vector_Sl_int64_t_Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = *result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_setitem___(void * jarg1, int jarg2, long long jarg3) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  long *arg3 = 0 ;
  long temp3 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (long)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_int64_t_Sg__setitem(arg1,arg2,(long const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  std::vector< long > *arg2 = 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (std::vector< long > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< long > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_int64_t_Sg__AddRange(arg1,(std::vector< long > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< long > *result = 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< long > *)std_vector_Sl_int64_t_Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_Insert___(void * jarg1, int jarg2, long long jarg3) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  long *arg3 = 0 ;
  long temp3 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (long)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_int64_t_Sg__Insert(arg1,arg2,(long const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  std::vector< long > *arg3 = 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< long > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< long > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_int64_t_Sg__InsertRange(arg1,arg2,(std::vector< long > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_int64_t_Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_int64_t_Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_Repeat___(long long jarg1, int jarg2) {
  void * jresult ;
  long *arg1 = 0 ;
  int arg2 ;
  long temp1 ;
  std::vector< long > *result = 0 ;
  
  temp1 = (long)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< long > *)std_vector_Sl_int64_t_Sg__Repeat((long const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  std_vector_Sl_int64_t_Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_int64_t_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  int arg2 ;
  std::vector< long > *arg3 = 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< long > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< long > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_int64_t_Sg__SetRange(arg1,arg2,(std::vector< long > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_Contains___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  long *arg2 = 0 ;
  long temp2 ;
  bool result;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  temp2 = (long)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int64_t_Sg__Contains(arg1,(long const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_IndexOf___(void * jarg1, long long jarg2) {
  int jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  long *arg2 = 0 ;
  long temp2 ;
  int result;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  temp2 = (long)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_int64_t_Sg__IndexOf(arg1,(long const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_LastIndexOf___(void * jarg1, long long jarg2) {
  int jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  long *arg2 = 0 ;
  long temp2 ;
  int result;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  temp2 = (long)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_int64_t_Sg__LastIndexOf(arg1,(long const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64Vector_Remove___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  long *arg2 = 0 ;
  long temp2 ;
  bool result;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  temp2 = (long)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int64_t_Sg__Remove(arg1,(long const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Int64Vector___(void * jarg1) {
  std::vector< int64_t > *arg1 = (std::vector< int64_t > *) 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_Clear___(void * jarg1) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_Add___(void * jarg1, void * jarg2) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (std::vector< int64_t > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
    return ;
  } 
  (arg1)->push_back((std::vector< int64_t > const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  std::vector< std::vector< long > >::size_type result;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  result = ((std::vector< std::vector< int64_t > > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  std::vector< std::vector< long > >::size_type result;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  result = ((std::vector< std::vector< int64_t > > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  std::vector< std::vector< long > >::size_type arg2 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (std::vector< std::vector< long > >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Int64VectorVector__SWIG_0___() {
  void * jresult ;
  std::vector< std::vector< int64_t > > *result = 0 ;
  
  result = (std::vector< std::vector< int64_t > > *)new std::vector< std::vector< int64_t > >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Int64VectorVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< std::vector< int64_t > > *arg1 = 0 ;
  std::vector< std::vector< int64_t > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int64_t > > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< std::vector< int64_t > > *)new std::vector< std::vector< int64_t > >((std::vector< std::vector< int64_t > > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Int64VectorVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::vector< int64_t > > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< std::vector< int64_t > > *)new_std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  std::vector< int64_t > result;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = new std::vector< int64_t >((const std::vector< int64_t > &)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< long > >::value_type *result = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< std::vector< long > >::value_type *) &std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int64_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__setitem(arg1,arg2,(std::vector< long > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  std::vector< std::vector< int64_t > > *arg2 = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (std::vector< std::vector< int64_t > > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int64_t > > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__AddRange(arg1,(std::vector< std::vector< long > > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::vector< int64_t > > *result = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< std::vector< int64_t > > *)std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int64_t > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Insert(arg1,arg2,(std::vector< long > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< int64_t > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< int64_t > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int64_t > > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__InsertRange(arg1,arg2,(std::vector< std::vector< long > > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< int64_t > *arg1 = 0 ;
  int arg2 ;
  std::vector< std::vector< int64_t > > *result = 0 ;
  
  arg1 = (std::vector< int64_t > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int64_t > const & type is null", 0);
    return 0;
  } 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< std::vector< int64_t > > *)std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Repeat((std::vector< long > const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Int64VectorVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  int arg2 ;
  std::vector< std::vector< int64_t > > *arg3 = 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::vector< int64_t > > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::vector< int64_t > > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_vector_Sl_int64_t_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::vector< long > > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Int64VectorVector___(void * jarg1) {
  std::vector< std::vector< int64_t > > *arg1 = (std::vector< std::vector< int64_t > > *) 0 ;
  
  arg1 = (std::vector< std::vector< int64_t > > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntTupleSet__SWIG_0___(int jarg1) {
  void * jresult ;
  int arg1 ;
  operations_research::IntTupleSet *result = 0 ;
  
  arg1 = (int)jarg1; 
  result = (operations_research::IntTupleSet *)new operations_research::IntTupleSet(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntTupleSet__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::IntTupleSet *arg1 = 0 ;
  operations_research::IntTupleSet *result = 0 ;
  
  arg1 = (operations_research::IntTupleSet *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::IntTupleSet const & type is null", 0);
    return 0;
  } 
  result = (operations_research::IntTupleSet *)new operations_research::IntTupleSet((operations_research::IntTupleSet const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntTupleSet___(void * jarg1) {
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Clear___(void * jarg1) {
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  (arg1)->Clear();
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Insert__SWIG_0___(void * jarg1,  int length2, int*  jarg2) {
  int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  std::vector< int > *arg2 = 0 ;
  int result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (int)(arg1)->Insert((std::vector< int > const &)*arg2);
  jresult = result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Insert__SWIG_1___(void * jarg1,  int length2, int64_t*  jarg2) {
  int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  int result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (int)(arg1)->Insert((std::vector< int64_t > const &)*arg2);
  jresult = result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Insert2___(void * jarg1, long long jarg2, long long jarg3) {
  int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (int)(arg1)->Insert2(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Insert3___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (int)(arg1)->Insert3(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Insert4___(void * jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5) {
  int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  int result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  result = (int)(arg1)->Insert4(arg2,arg3,arg4,arg5);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_InsertAll__SWIG_0___(void * jarg1, 
  int len2_1, int len2_2[], int64_t*
  jarg2) {
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  std::vector< std::vector< int64_t > > *arg2 = 0 ;
  std::vector< std::vector< int64_t > > result2 ;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  
  result2.clear();
  result2.resize(len2_1);
  
  int64_t* inner_array = reinterpret_cast<int64_t*>(jarg2);
  int actualIndex = 0;
  for (int index1 = 0; index1 < len2_1; ++index1) {
    result2[index1].reserve(len2_2[index1]);
    for (int index2 = 0; index2 < len2_2[index1]; ++index2) {
      const int64_t value = inner_array[actualIndex];
      result2[index1].emplace_back(value);
      actualIndex++;
    }
  }
  
  arg2 = &result2;
  
  (arg1)->InsertAll((std::vector< std::vector< int64_t > > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_InsertAll__SWIG_1___(void * jarg1, 
  int len2_1, int len2_2[], int*
  jarg2) {
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  std::vector< std::vector< int > > *arg2 = 0 ;
  std::vector< std::vector< int > > result2 ;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  
  result2.clear();
  result2.resize(len2_1);
  
  int* inner_array = reinterpret_cast<int*>(jarg2);
  int actualIndex = 0;
  for (int index1 = 0; index1 < len2_1; ++index1) {
    result2[index1].reserve(len2_2[index1]);
    for (int index2 = 0; index2 < len2_2[index1]; ++index2) {
      const int value = inner_array[actualIndex];
      result2[index1].emplace_back(value);
      actualIndex++;
    }
  }
  
  arg2 = &result2;
  
  (arg1)->InsertAll((std::vector< std::vector< int > > const &)*arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Contains__SWIG_0___(void * jarg1,  int length2, int*  jarg2) {
  unsigned int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  std::vector< int > *arg2 = 0 ;
  bool result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (bool)((operations_research::IntTupleSet const *)arg1)->Contains((std::vector< int > const &)*arg2);
  jresult = result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Contains__SWIG_1___(void * jarg1,  int length2, int64_t*  jarg2) {
  unsigned int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  bool result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (bool)((operations_research::IntTupleSet const *)arg1)->Contains((std::vector< int64_t > const &)*arg2);
  jresult = result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_NumTuples___(void * jarg1) {
  int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  int result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  result = (int)((operations_research::IntTupleSet const *)arg1)->NumTuples();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Value___(void * jarg1, int jarg2, int jarg3) {
  long long jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  int arg2 ;
  int arg3 ;
  int64_t result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  result = (int64_t)((operations_research::IntTupleSet const *)arg1)->Value(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_Arity___(void * jarg1) {
  int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  int result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  result = (int)((operations_research::IntTupleSet const *)arg1)->Arity();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_NumDifferentValuesInColumn___(void * jarg1, int jarg2) {
  int jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int)((operations_research::IntTupleSet const *)arg1)->NumDifferentValuesInColumn(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_SortedByColumn___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  int arg2 ;
  SwigValueWrapper< operations_research::IntTupleSet > result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  arg2 = (int)jarg2; 
  result = ((operations_research::IntTupleSet const *)arg1)->SortedByColumn(arg2);
  jresult = new operations_research::IntTupleSet((const operations_research::IntTupleSet &)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntTupleSet_SortedLexicographically___(void * jarg1) {
  void * jresult ;
  operations_research::IntTupleSet *arg1 = (operations_research::IntTupleSet *) 0 ;
  SwigValueWrapper< operations_research::IntTupleSet > result;
  
  arg1 = (operations_research::IntTupleSet *)jarg1; 
  result = ((operations_research::IntTupleSet const *)arg1)->SortedLexicographically();
  jresult = new operations_research::IntTupleSet((const operations_research::IntTupleSet &)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchPhaseParameters___() {
  void * jresult ;
  operations_research::LocalSearchPhaseParameters *result = 0 ;
  
  result = (operations_research::LocalSearchPhaseParameters *)new operations_research::LocalSearchPhaseParameters();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_LocalSearchPhaseParameters___(void * jarg1) {
  operations_research::LocalSearchPhaseParameters *arg1 = (operations_research::LocalSearchPhaseParameters *) 0 ;
  
  arg1 = (operations_research::LocalSearchPhaseParameters *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_Clear___(void * jarg1) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_Add___(void * jarg1, void * jarg2) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  operations_research::IntVar **arg2 = 0 ;
  operations_research::IntVar *temp2 = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  temp2 = (operations_research::IntVar *)jarg2;
  arg2 = (operations_research::IntVar **)&temp2; 
  (arg1)->push_back((operations_research::IntVar *const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  std::vector< operations_research::IntVar * >::size_type result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  result = ((std::vector< operations_research::IntVar * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  std::vector< operations_research::IntVar * >::size_type result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  result = ((std::vector< operations_research::IntVar * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  std::vector< operations_research::IntVar * >::size_type arg2 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarVector__SWIG_0___() {
  void * jresult ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  result = (std::vector< operations_research::IntVar * > *)new std::vector< operations_research::IntVar * >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< operations_research::IntVar * > *)new std::vector< operations_research::IntVar * >((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< operations_research::IntVar * > *)new_std_vector_Sl_operations_research_IntVar_Sm__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (operations_research::IntVar *)std_vector_Sl_operations_research_IntVar_Sm__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::IntVar * >::value_type *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::IntVar * >::value_type *) &std_vector_Sl_operations_research_IntVar_Sm__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)*result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  operations_research::IntVar **arg3 = 0 ;
  operations_research::IntVar *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::IntVar *)jarg3;
  arg3 = (operations_research::IntVar **)&temp3; 
  try {
    std_vector_Sl_operations_research_IntVar_Sm__Sg__setitem(arg1,arg2,(operations_research::IntVar *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_operations_research_IntVar_Sm__Sg__AddRange(arg1,(std::vector< operations_research::IntVar * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< operations_research::IntVar * > *)std_vector_Sl_operations_research_IntVar_Sm__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  operations_research::IntVar **arg3 = 0 ;
  operations_research::IntVar *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::IntVar *)jarg3;
  arg3 = (operations_research::IntVar **)&temp3; 
  try {
    std_vector_Sl_operations_research_IntVar_Sm__Sg__Insert(arg1,arg2,(operations_research::IntVar *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_IntVar_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_operations_research_IntVar_Sm__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_IntVar_Sm__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::IntVar **arg1 = 0 ;
  int arg2 ;
  operations_research::IntVar *temp1 = 0 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  temp1 = (operations_research::IntVar *)jarg1;
  arg1 = (operations_research::IntVar **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::IntVar * > *)std_vector_Sl_operations_research_IntVar_Sm__Sg__Repeat((operations_research::IntVar *const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  std_vector_Sl_operations_research_IntVar_Sm__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_IntVar_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_IntVar_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  operations_research::IntVar **arg2 = 0 ;
  operations_research::IntVar *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  temp2 = (operations_research::IntVar *)jarg2;
  arg2 = (operations_research::IntVar **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_IntVar_Sm__Sg__Contains(arg1,(operations_research::IntVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_IndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  operations_research::IntVar **arg2 = 0 ;
  operations_research::IntVar *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  temp2 = (operations_research::IntVar *)jarg2;
  arg2 = (operations_research::IntVar **)&temp2; 
  result = (int)std_vector_Sl_operations_research_IntVar_Sm__Sg__IndexOf(arg1,(operations_research::IntVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_LastIndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  operations_research::IntVar **arg2 = 0 ;
  operations_research::IntVar *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  temp2 = (operations_research::IntVar *)jarg2;
  arg2 = (operations_research::IntVar **)&temp2; 
  result = (int)std_vector_Sl_operations_research_IntVar_Sm__Sg__LastIndexOf(arg1,(operations_research::IntVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarVector_Remove___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  operations_research::IntVar **arg2 = 0 ;
  operations_research::IntVar *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  temp2 = (operations_research::IntVar *)jarg2;
  arg2 = (operations_research::IntVar **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_IntVar_Sm__Sg__Remove(arg1,(operations_research::IntVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVarVector___(void * jarg1) {
  std::vector< operations_research::IntVar * > *arg1 = (std::vector< operations_research::IntVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_Clear___(void * jarg1) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_Add___(void * jarg1, void * jarg2) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  operations_research::SearchMonitor **arg2 = 0 ;
  operations_research::SearchMonitor *temp2 = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  temp2 = (operations_research::SearchMonitor *)jarg2;
  arg2 = (operations_research::SearchMonitor **)&temp2; 
  (arg1)->push_back((operations_research::SearchMonitor *const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  std::vector< operations_research::SearchMonitor * >::size_type result;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  result = ((std::vector< operations_research::SearchMonitor * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  std::vector< operations_research::SearchMonitor * >::size_type result;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  result = ((std::vector< operations_research::SearchMonitor * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  std::vector< operations_research::SearchMonitor * >::size_type arg2 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (std::vector< operations_research::SearchMonitor * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SearchMonitorVector__SWIG_0___() {
  void * jresult ;
  std::vector< operations_research::SearchMonitor * > *result = 0 ;
  
  result = (std::vector< operations_research::SearchMonitor * > *)new std::vector< operations_research::SearchMonitor * >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SearchMonitorVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = 0 ;
  std::vector< operations_research::SearchMonitor * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< operations_research::SearchMonitor * > *)new std::vector< operations_research::SearchMonitor * >((std::vector< operations_research::SearchMonitor * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SearchMonitorVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< operations_research::SearchMonitor * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< operations_research::SearchMonitor * > *)new_std_vector_Sl_operations_research_SearchMonitor_Sm__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (operations_research::SearchMonitor *)std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SearchMonitor * >::value_type *result = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::SearchMonitor * >::value_type *) &std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)*result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  operations_research::SearchMonitor **arg3 = 0 ;
  operations_research::SearchMonitor *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::SearchMonitor *)jarg3;
  arg3 = (operations_research::SearchMonitor **)&temp3; 
  try {
    std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__setitem(arg1,arg2,(operations_research::SearchMonitor *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  std::vector< operations_research::SearchMonitor * > *arg2 = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (std::vector< operations_research::SearchMonitor * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__AddRange(arg1,(std::vector< operations_research::SearchMonitor * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< operations_research::SearchMonitor * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< operations_research::SearchMonitor * > *)std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  operations_research::SearchMonitor **arg3 = 0 ;
  operations_research::SearchMonitor *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::SearchMonitor *)jarg3;
  arg3 = (operations_research::SearchMonitor **)&temp3; 
  try {
    std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Insert(arg1,arg2,(operations_research::SearchMonitor *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SearchMonitor * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::SearchMonitor * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::SearchMonitor * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::SearchMonitor **arg1 = 0 ;
  int arg2 ;
  operations_research::SearchMonitor *temp1 = 0 ;
  std::vector< operations_research::SearchMonitor * > *result = 0 ;
  
  temp1 = (operations_research::SearchMonitor *)jarg1;
  arg1 = (operations_research::SearchMonitor **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::SearchMonitor * > *)std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Repeat((operations_research::SearchMonitor *const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SearchMonitor * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::SearchMonitor * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::SearchMonitor * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  operations_research::SearchMonitor **arg2 = 0 ;
  operations_research::SearchMonitor *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  temp2 = (operations_research::SearchMonitor *)jarg2;
  arg2 = (operations_research::SearchMonitor **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Contains(arg1,(operations_research::SearchMonitor *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_IndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  operations_research::SearchMonitor **arg2 = 0 ;
  operations_research::SearchMonitor *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  temp2 = (operations_research::SearchMonitor *)jarg2;
  arg2 = (operations_research::SearchMonitor **)&temp2; 
  result = (int)std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__IndexOf(arg1,(operations_research::SearchMonitor *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_LastIndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  operations_research::SearchMonitor **arg2 = 0 ;
  operations_research::SearchMonitor *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  temp2 = (operations_research::SearchMonitor *)jarg2;
  arg2 = (operations_research::SearchMonitor **)&temp2; 
  result = (int)std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__LastIndexOf(arg1,(operations_research::SearchMonitor *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitorVector_Remove___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  operations_research::SearchMonitor **arg2 = 0 ;
  operations_research::SearchMonitor *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  temp2 = (operations_research::SearchMonitor *)jarg2;
  arg2 = (operations_research::SearchMonitor **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_SearchMonitor_Sm__Sg__Remove(arg1,(operations_research::SearchMonitor *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SearchMonitorVector___(void * jarg1) {
  std::vector< operations_research::SearchMonitor * > *arg1 = (std::vector< operations_research::SearchMonitor * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SearchMonitor * > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_Clear___(void * jarg1) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_Add___(void * jarg1, void * jarg2) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  operations_research::DecisionBuilder **arg2 = 0 ;
  operations_research::DecisionBuilder *temp2 = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  temp2 = (operations_research::DecisionBuilder *)jarg2;
  arg2 = (operations_research::DecisionBuilder **)&temp2; 
  (arg1)->push_back((operations_research::DecisionBuilder *const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  std::vector< operations_research::DecisionBuilder * >::size_type result;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  result = ((std::vector< operations_research::DecisionBuilder * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  std::vector< operations_research::DecisionBuilder * >::size_type result;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  result = ((std::vector< operations_research::DecisionBuilder * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  std::vector< operations_research::DecisionBuilder * >::size_type arg2 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (std::vector< operations_research::DecisionBuilder * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_DecisionBuilderVector__SWIG_0___() {
  void * jresult ;
  std::vector< operations_research::DecisionBuilder * > *result = 0 ;
  
  result = (std::vector< operations_research::DecisionBuilder * > *)new std::vector< operations_research::DecisionBuilder * >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_DecisionBuilderVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = 0 ;
  std::vector< operations_research::DecisionBuilder * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::DecisionBuilder * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< operations_research::DecisionBuilder * > *)new std::vector< operations_research::DecisionBuilder * >((std::vector< operations_research::DecisionBuilder * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_DecisionBuilderVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< operations_research::DecisionBuilder * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< operations_research::DecisionBuilder * > *)new_std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (operations_research::DecisionBuilder *)std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::DecisionBuilder * >::value_type *result = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::DecisionBuilder * >::value_type *) &std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)*result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  operations_research::DecisionBuilder **arg3 = 0 ;
  operations_research::DecisionBuilder *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::DecisionBuilder *)jarg3;
  arg3 = (operations_research::DecisionBuilder **)&temp3; 
  try {
    std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__setitem(arg1,arg2,(operations_research::DecisionBuilder *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  std::vector< operations_research::DecisionBuilder * > *arg2 = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (std::vector< operations_research::DecisionBuilder * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::DecisionBuilder * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__AddRange(arg1,(std::vector< operations_research::DecisionBuilder * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< operations_research::DecisionBuilder * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< operations_research::DecisionBuilder * > *)std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  operations_research::DecisionBuilder **arg3 = 0 ;
  operations_research::DecisionBuilder *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::DecisionBuilder *)jarg3;
  arg3 = (operations_research::DecisionBuilder **)&temp3; 
  try {
    std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Insert(arg1,arg2,(operations_research::DecisionBuilder *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::DecisionBuilder * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::DecisionBuilder * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::DecisionBuilder * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::DecisionBuilder * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::DecisionBuilder **arg1 = 0 ;
  int arg2 ;
  operations_research::DecisionBuilder *temp1 = 0 ;
  std::vector< operations_research::DecisionBuilder * > *result = 0 ;
  
  temp1 = (operations_research::DecisionBuilder *)jarg1;
  arg1 = (operations_research::DecisionBuilder **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::DecisionBuilder * > *)std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Repeat((operations_research::DecisionBuilder *const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::DecisionBuilder * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::DecisionBuilder * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::DecisionBuilder * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::DecisionBuilder * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  operations_research::DecisionBuilder **arg2 = 0 ;
  operations_research::DecisionBuilder *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  temp2 = (operations_research::DecisionBuilder *)jarg2;
  arg2 = (operations_research::DecisionBuilder **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Contains(arg1,(operations_research::DecisionBuilder *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_IndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  operations_research::DecisionBuilder **arg2 = 0 ;
  operations_research::DecisionBuilder *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  temp2 = (operations_research::DecisionBuilder *)jarg2;
  arg2 = (operations_research::DecisionBuilder **)&temp2; 
  result = (int)std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__IndexOf(arg1,(operations_research::DecisionBuilder *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_LastIndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  operations_research::DecisionBuilder **arg2 = 0 ;
  operations_research::DecisionBuilder *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  temp2 = (operations_research::DecisionBuilder *)jarg2;
  arg2 = (operations_research::DecisionBuilder **)&temp2; 
  result = (int)std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__LastIndexOf(arg1,(operations_research::DecisionBuilder *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilderVector_Remove___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  operations_research::DecisionBuilder **arg2 = 0 ;
  operations_research::DecisionBuilder *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  temp2 = (operations_research::DecisionBuilder *)jarg2;
  arg2 = (operations_research::DecisionBuilder **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_DecisionBuilder_Sm__Sg__Remove(arg1,(operations_research::DecisionBuilder *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_DecisionBuilderVector___(void * jarg1) {
  std::vector< operations_research::DecisionBuilder * > *arg1 = (std::vector< operations_research::DecisionBuilder * > *) 0 ;
  
  arg1 = (std::vector< operations_research::DecisionBuilder * > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_Clear___(void * jarg1) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_Add___(void * jarg1, void * jarg2) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  operations_research::IntervalVar **arg2 = 0 ;
  operations_research::IntervalVar *temp2 = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  temp2 = (operations_research::IntervalVar *)jarg2;
  arg2 = (operations_research::IntervalVar **)&temp2; 
  (arg1)->push_back((operations_research::IntervalVar *const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  std::vector< operations_research::IntervalVar * >::size_type result;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  result = ((std::vector< operations_research::IntervalVar * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  std::vector< operations_research::IntervalVar * >::size_type result;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  result = ((std::vector< operations_research::IntervalVar * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  std::vector< operations_research::IntervalVar * >::size_type arg2 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntervalVarVector__SWIG_0___() {
  void * jresult ;
  std::vector< operations_research::IntervalVar * > *result = 0 ;
  
  result = (std::vector< operations_research::IntervalVar * > *)new std::vector< operations_research::IntervalVar * >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntervalVarVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = 0 ;
  std::vector< operations_research::IntervalVar * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< operations_research::IntervalVar * > *)new std::vector< operations_research::IntervalVar * >((std::vector< operations_research::IntervalVar * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntervalVarVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< operations_research::IntervalVar * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< operations_research::IntervalVar * > *)new_std_vector_Sl_operations_research_IntervalVar_Sm__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (operations_research::IntervalVar *)std_vector_Sl_operations_research_IntervalVar_Sm__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::IntervalVar * >::value_type *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::IntervalVar * >::value_type *) &std_vector_Sl_operations_research_IntervalVar_Sm__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)*result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  operations_research::IntervalVar **arg3 = 0 ;
  operations_research::IntervalVar *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::IntervalVar *)jarg3;
  arg3 = (operations_research::IntervalVar **)&temp3; 
  try {
    std_vector_Sl_operations_research_IntervalVar_Sm__Sg__setitem(arg1,arg2,(operations_research::IntervalVar *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_operations_research_IntervalVar_Sm__Sg__AddRange(arg1,(std::vector< operations_research::IntervalVar * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< operations_research::IntervalVar * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< operations_research::IntervalVar * > *)std_vector_Sl_operations_research_IntervalVar_Sm__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  operations_research::IntervalVar **arg3 = 0 ;
  operations_research::IntervalVar *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::IntervalVar *)jarg3;
  arg3 = (operations_research::IntervalVar **)&temp3; 
  try {
    std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Insert(arg1,arg2,(operations_research::IntervalVar *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::IntervalVar * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::IntervalVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_IntervalVar_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::IntervalVar * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_operations_research_IntervalVar_Sm__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_IntervalVar_Sm__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::IntervalVar **arg1 = 0 ;
  int arg2 ;
  operations_research::IntervalVar *temp1 = 0 ;
  std::vector< operations_research::IntervalVar * > *result = 0 ;
  
  temp1 = (operations_research::IntervalVar *)jarg1;
  arg1 = (operations_research::IntervalVar **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::IntervalVar * > *)std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Repeat((operations_research::IntervalVar *const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::IntervalVar * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::IntervalVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_IntervalVar_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::IntervalVar * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  operations_research::IntervalVar **arg2 = 0 ;
  operations_research::IntervalVar *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  temp2 = (operations_research::IntervalVar *)jarg2;
  arg2 = (operations_research::IntervalVar **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Contains(arg1,(operations_research::IntervalVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_IndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  operations_research::IntervalVar **arg2 = 0 ;
  operations_research::IntervalVar *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  temp2 = (operations_research::IntervalVar *)jarg2;
  arg2 = (operations_research::IntervalVar **)&temp2; 
  result = (int)std_vector_Sl_operations_research_IntervalVar_Sm__Sg__IndexOf(arg1,(operations_research::IntervalVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_LastIndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  operations_research::IntervalVar **arg2 = 0 ;
  operations_research::IntervalVar *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  temp2 = (operations_research::IntervalVar *)jarg2;
  arg2 = (operations_research::IntervalVar **)&temp2; 
  result = (int)std_vector_Sl_operations_research_IntervalVar_Sm__Sg__LastIndexOf(arg1,(operations_research::IntervalVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarVector_Remove___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  operations_research::IntervalVar **arg2 = 0 ;
  operations_research::IntervalVar *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  temp2 = (operations_research::IntervalVar *)jarg2;
  arg2 = (operations_research::IntervalVar **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_IntervalVar_Sm__Sg__Remove(arg1,(operations_research::IntervalVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntervalVarVector___(void * jarg1) {
  std::vector< operations_research::IntervalVar * > *arg1 = (std::vector< operations_research::IntervalVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::IntervalVar * > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_Clear___(void * jarg1) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_Add___(void * jarg1, void * jarg2) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  operations_research::SequenceVar **arg2 = 0 ;
  operations_research::SequenceVar *temp2 = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  temp2 = (operations_research::SequenceVar *)jarg2;
  arg2 = (operations_research::SequenceVar **)&temp2; 
  (arg1)->push_back((operations_research::SequenceVar *const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  std::vector< operations_research::SequenceVar * >::size_type result;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  result = ((std::vector< operations_research::SequenceVar * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  std::vector< operations_research::SequenceVar * >::size_type result;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  result = ((std::vector< operations_research::SequenceVar * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  std::vector< operations_research::SequenceVar * >::size_type arg2 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (std::vector< operations_research::SequenceVar * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SequenceVarVector__SWIG_0___() {
  void * jresult ;
  std::vector< operations_research::SequenceVar * > *result = 0 ;
  
  result = (std::vector< operations_research::SequenceVar * > *)new std::vector< operations_research::SequenceVar * >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SequenceVarVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = 0 ;
  std::vector< operations_research::SequenceVar * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< operations_research::SequenceVar * > *)new std::vector< operations_research::SequenceVar * >((std::vector< operations_research::SequenceVar * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SequenceVarVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< operations_research::SequenceVar * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< operations_research::SequenceVar * > *)new_std_vector_Sl_operations_research_SequenceVar_Sm__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  operations_research::SequenceVar *result = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (operations_research::SequenceVar *)std_vector_Sl_operations_research_SequenceVar_Sm__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SequenceVar * >::value_type *result = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::SequenceVar * >::value_type *) &std_vector_Sl_operations_research_SequenceVar_Sm__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)*result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  operations_research::SequenceVar **arg3 = 0 ;
  operations_research::SequenceVar *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::SequenceVar *)jarg3;
  arg3 = (operations_research::SequenceVar **)&temp3; 
  try {
    std_vector_Sl_operations_research_SequenceVar_Sm__Sg__setitem(arg1,arg2,(operations_research::SequenceVar *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  std::vector< operations_research::SequenceVar * > *arg2 = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (std::vector< operations_research::SequenceVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_operations_research_SequenceVar_Sm__Sg__AddRange(arg1,(std::vector< operations_research::SequenceVar * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< operations_research::SequenceVar * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< operations_research::SequenceVar * > *)std_vector_Sl_operations_research_SequenceVar_Sm__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  operations_research::SequenceVar **arg3 = 0 ;
  operations_research::SequenceVar *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::SequenceVar *)jarg3;
  arg3 = (operations_research::SequenceVar **)&temp3; 
  try {
    std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Insert(arg1,arg2,(operations_research::SequenceVar *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SequenceVar * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::SequenceVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_SequenceVar_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::SequenceVar * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_operations_research_SequenceVar_Sm__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_SequenceVar_Sm__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::SequenceVar **arg1 = 0 ;
  int arg2 ;
  operations_research::SequenceVar *temp1 = 0 ;
  std::vector< operations_research::SequenceVar * > *result = 0 ;
  
  temp1 = (operations_research::SequenceVar *)jarg1;
  arg1 = (operations_research::SequenceVar **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::SequenceVar * > *)std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Repeat((operations_research::SequenceVar *const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SequenceVar * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::SequenceVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_SequenceVar_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::SequenceVar * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  operations_research::SequenceVar **arg2 = 0 ;
  operations_research::SequenceVar *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  temp2 = (operations_research::SequenceVar *)jarg2;
  arg2 = (operations_research::SequenceVar **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Contains(arg1,(operations_research::SequenceVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_IndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  operations_research::SequenceVar **arg2 = 0 ;
  operations_research::SequenceVar *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  temp2 = (operations_research::SequenceVar *)jarg2;
  arg2 = (operations_research::SequenceVar **)&temp2; 
  result = (int)std_vector_Sl_operations_research_SequenceVar_Sm__Sg__IndexOf(arg1,(operations_research::SequenceVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_LastIndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  operations_research::SequenceVar **arg2 = 0 ;
  operations_research::SequenceVar *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  temp2 = (operations_research::SequenceVar *)jarg2;
  arg2 = (operations_research::SequenceVar **)&temp2; 
  result = (int)std_vector_Sl_operations_research_SequenceVar_Sm__Sg__LastIndexOf(arg1,(operations_research::SequenceVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarVector_Remove___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  operations_research::SequenceVar **arg2 = 0 ;
  operations_research::SequenceVar *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  temp2 = (operations_research::SequenceVar *)jarg2;
  arg2 = (operations_research::SequenceVar **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_SequenceVar_Sm__Sg__Remove(arg1,(operations_research::SequenceVar *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SequenceVarVector___(void * jarg1) {
  std::vector< operations_research::SequenceVar * > *arg1 = (std::vector< operations_research::SequenceVar * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_Clear___(void * jarg1) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_Add___(void * jarg1, void * jarg2) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  operations_research::LocalSearchOperator **arg2 = 0 ;
  operations_research::LocalSearchOperator *temp2 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  temp2 = (operations_research::LocalSearchOperator *)jarg2;
  arg2 = (operations_research::LocalSearchOperator **)&temp2; 
  (arg1)->push_back((operations_research::LocalSearchOperator *const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  std::vector< operations_research::LocalSearchOperator * >::size_type result;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  result = ((std::vector< operations_research::LocalSearchOperator * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  std::vector< operations_research::LocalSearchOperator * >::size_type result;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  result = ((std::vector< operations_research::LocalSearchOperator * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  std::vector< operations_research::LocalSearchOperator * >::size_type arg2 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchOperator * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchOperatorVector__SWIG_0___() {
  void * jresult ;
  std::vector< operations_research::LocalSearchOperator * > *result = 0 ;
  
  result = (std::vector< operations_research::LocalSearchOperator * > *)new std::vector< operations_research::LocalSearchOperator * >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchOperatorVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = 0 ;
  std::vector< operations_research::LocalSearchOperator * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< operations_research::LocalSearchOperator * > *)new std::vector< operations_research::LocalSearchOperator * >((std::vector< operations_research::LocalSearchOperator * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchOperatorVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< operations_research::LocalSearchOperator * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< operations_research::LocalSearchOperator * > *)new_std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (operations_research::LocalSearchOperator *)std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::LocalSearchOperator * >::value_type *result = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::LocalSearchOperator * >::value_type *) &std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)*result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  operations_research::LocalSearchOperator **arg3 = 0 ;
  operations_research::LocalSearchOperator *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::LocalSearchOperator *)jarg3;
  arg3 = (operations_research::LocalSearchOperator **)&temp3; 
  try {
    std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__setitem(arg1,arg2,(operations_research::LocalSearchOperator *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  std::vector< operations_research::LocalSearchOperator * > *arg2 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchOperator * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__AddRange(arg1,(std::vector< operations_research::LocalSearchOperator * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< operations_research::LocalSearchOperator * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< operations_research::LocalSearchOperator * > *)std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  operations_research::LocalSearchOperator **arg3 = 0 ;
  operations_research::LocalSearchOperator *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::LocalSearchOperator *)jarg3;
  arg3 = (operations_research::LocalSearchOperator **)&temp3; 
  try {
    std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Insert(arg1,arg2,(operations_research::LocalSearchOperator *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::LocalSearchOperator * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::LocalSearchOperator * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::LocalSearchOperator * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::LocalSearchOperator **arg1 = 0 ;
  int arg2 ;
  operations_research::LocalSearchOperator *temp1 = 0 ;
  std::vector< operations_research::LocalSearchOperator * > *result = 0 ;
  
  temp1 = (operations_research::LocalSearchOperator *)jarg1;
  arg1 = (operations_research::LocalSearchOperator **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::LocalSearchOperator * > *)std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Repeat((operations_research::LocalSearchOperator *const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::LocalSearchOperator * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::LocalSearchOperator * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::LocalSearchOperator * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  operations_research::LocalSearchOperator **arg2 = 0 ;
  operations_research::LocalSearchOperator *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  temp2 = (operations_research::LocalSearchOperator *)jarg2;
  arg2 = (operations_research::LocalSearchOperator **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Contains(arg1,(operations_research::LocalSearchOperator *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_IndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  operations_research::LocalSearchOperator **arg2 = 0 ;
  operations_research::LocalSearchOperator *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  temp2 = (operations_research::LocalSearchOperator *)jarg2;
  arg2 = (operations_research::LocalSearchOperator **)&temp2; 
  result = (int)std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__IndexOf(arg1,(operations_research::LocalSearchOperator *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_LastIndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  operations_research::LocalSearchOperator **arg2 = 0 ;
  operations_research::LocalSearchOperator *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  temp2 = (operations_research::LocalSearchOperator *)jarg2;
  arg2 = (operations_research::LocalSearchOperator **)&temp2; 
  result = (int)std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__LastIndexOf(arg1,(operations_research::LocalSearchOperator *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperatorVector_Remove___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  operations_research::LocalSearchOperator **arg2 = 0 ;
  operations_research::LocalSearchOperator *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  temp2 = (operations_research::LocalSearchOperator *)jarg2;
  arg2 = (operations_research::LocalSearchOperator **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_LocalSearchOperator_Sm__Sg__Remove(arg1,(operations_research::LocalSearchOperator *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_LocalSearchOperatorVector___(void * jarg1) {
  std::vector< operations_research::LocalSearchOperator * > *arg1 = (std::vector< operations_research::LocalSearchOperator * > *) 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchOperator * > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_Clear___(void * jarg1) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_Add___(void * jarg1, void * jarg2) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  operations_research::LocalSearchFilter **arg2 = 0 ;
  operations_research::LocalSearchFilter *temp2 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  temp2 = (operations_research::LocalSearchFilter *)jarg2;
  arg2 = (operations_research::LocalSearchFilter **)&temp2; 
  (arg1)->push_back((operations_research::LocalSearchFilter *const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  std::vector< operations_research::LocalSearchFilter * >::size_type result;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  result = ((std::vector< operations_research::LocalSearchFilter * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  std::vector< operations_research::LocalSearchFilter * >::size_type result;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  result = ((std::vector< operations_research::LocalSearchFilter * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  std::vector< operations_research::LocalSearchFilter * >::size_type arg2 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchFilter * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchFilterVector__SWIG_0___() {
  void * jresult ;
  std::vector< operations_research::LocalSearchFilter * > *result = 0 ;
  
  result = (std::vector< operations_research::LocalSearchFilter * > *)new std::vector< operations_research::LocalSearchFilter * >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchFilterVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = 0 ;
  std::vector< operations_research::LocalSearchFilter * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchFilter * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< operations_research::LocalSearchFilter * > *)new std::vector< operations_research::LocalSearchFilter * >((std::vector< operations_research::LocalSearchFilter * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchFilterVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< operations_research::LocalSearchFilter * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< operations_research::LocalSearchFilter * > *)new_std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  operations_research::LocalSearchFilter *result = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (operations_research::LocalSearchFilter *)std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::LocalSearchFilter * >::value_type *result = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::LocalSearchFilter * >::value_type *) &std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)*result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  operations_research::LocalSearchFilter **arg3 = 0 ;
  operations_research::LocalSearchFilter *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::LocalSearchFilter *)jarg3;
  arg3 = (operations_research::LocalSearchFilter **)&temp3; 
  try {
    std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__setitem(arg1,arg2,(operations_research::LocalSearchFilter *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  std::vector< operations_research::LocalSearchFilter * > *arg2 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchFilter * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchFilter * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__AddRange(arg1,(std::vector< operations_research::LocalSearchFilter * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< operations_research::LocalSearchFilter * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< operations_research::LocalSearchFilter * > *)std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  operations_research::LocalSearchFilter **arg3 = 0 ;
  operations_research::LocalSearchFilter *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::LocalSearchFilter *)jarg3;
  arg3 = (operations_research::LocalSearchFilter **)&temp3; 
  try {
    std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Insert(arg1,arg2,(operations_research::LocalSearchFilter *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::LocalSearchFilter * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::LocalSearchFilter * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchFilter * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::LocalSearchFilter * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::LocalSearchFilter **arg1 = 0 ;
  int arg2 ;
  operations_research::LocalSearchFilter *temp1 = 0 ;
  std::vector< operations_research::LocalSearchFilter * > *result = 0 ;
  
  temp1 = (operations_research::LocalSearchFilter *)jarg1;
  arg1 = (operations_research::LocalSearchFilter **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::LocalSearchFilter * > *)std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Repeat((operations_research::LocalSearchFilter *const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::LocalSearchFilter * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::LocalSearchFilter * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchFilter * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::LocalSearchFilter * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  operations_research::LocalSearchFilter **arg2 = 0 ;
  operations_research::LocalSearchFilter *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  temp2 = (operations_research::LocalSearchFilter *)jarg2;
  arg2 = (operations_research::LocalSearchFilter **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Contains(arg1,(operations_research::LocalSearchFilter *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_IndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  operations_research::LocalSearchFilter **arg2 = 0 ;
  operations_research::LocalSearchFilter *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  temp2 = (operations_research::LocalSearchFilter *)jarg2;
  arg2 = (operations_research::LocalSearchFilter **)&temp2; 
  result = (int)std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__IndexOf(arg1,(operations_research::LocalSearchFilter *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_LastIndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  operations_research::LocalSearchFilter **arg2 = 0 ;
  operations_research::LocalSearchFilter *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  temp2 = (operations_research::LocalSearchFilter *)jarg2;
  arg2 = (operations_research::LocalSearchFilter **)&temp2; 
  result = (int)std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__LastIndexOf(arg1,(operations_research::LocalSearchFilter *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterVector_Remove___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  operations_research::LocalSearchFilter **arg2 = 0 ;
  operations_research::LocalSearchFilter *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  temp2 = (operations_research::LocalSearchFilter *)jarg2;
  arg2 = (operations_research::LocalSearchFilter **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_LocalSearchFilter_Sm__Sg__Remove(arg1,(operations_research::LocalSearchFilter *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_LocalSearchFilterVector___(void * jarg1) {
  std::vector< operations_research::LocalSearchFilter * > *arg1 = (std::vector< operations_research::LocalSearchFilter * > *) 0 ;
  
  arg1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_Clear___(void * jarg1) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  (arg1)->clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_Add___(void * jarg1, void * jarg2) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  operations_research::SymmetryBreaker **arg2 = 0 ;
  operations_research::SymmetryBreaker *temp2 = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  temp2 = (operations_research::SymmetryBreaker *)jarg2;
  arg2 = (operations_research::SymmetryBreaker **)&temp2; 
  (arg1)->push_back((operations_research::SymmetryBreaker *const &)*arg2);
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_size___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  std::vector< operations_research::SymmetryBreaker * >::size_type result;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  result = ((std::vector< operations_research::SymmetryBreaker * > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_capacity___(void * jarg1) {
  unsigned long jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  std::vector< operations_research::SymmetryBreaker * >::size_type result;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  result = ((std::vector< operations_research::SymmetryBreaker * > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_reserve___(void * jarg1, unsigned long jarg2) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  std::vector< operations_research::SymmetryBreaker * >::size_type arg2 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (std::vector< operations_research::SymmetryBreaker * >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SymmetryBreakerVector__SWIG_0___() {
  void * jresult ;
  std::vector< operations_research::SymmetryBreaker * > *result = 0 ;
  
  result = (std::vector< operations_research::SymmetryBreaker * > *)new std::vector< operations_research::SymmetryBreaker * >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SymmetryBreakerVector__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = 0 ;
  std::vector< operations_research::SymmetryBreaker * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SymmetryBreaker * > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< operations_research::SymmetryBreaker * > *)new std::vector< operations_research::SymmetryBreaker * >((std::vector< operations_research::SymmetryBreaker * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SymmetryBreakerVector__SWIG_2___(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< operations_research::SymmetryBreaker * > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< operations_research::SymmetryBreaker * > *)new_std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg___SWIG_2(arg1);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_getitemcopy___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  operations_research::SymmetryBreaker *result = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (operations_research::SymmetryBreaker *)std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__getitemcopy(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_getitem___(void * jarg1, int jarg2) {
  void * jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SymmetryBreaker * >::value_type *result = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::SymmetryBreaker * >::value_type *) &std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__getitem(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)*result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_setitem___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  operations_research::SymmetryBreaker **arg3 = 0 ;
  operations_research::SymmetryBreaker *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::SymmetryBreaker *)jarg3;
  arg3 = (operations_research::SymmetryBreaker **)&temp3; 
  try {
    std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__setitem(arg1,arg2,(operations_research::SymmetryBreaker *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_AddRange___(void * jarg1, void * jarg2) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  std::vector< operations_research::SymmetryBreaker * > *arg2 = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (std::vector< operations_research::SymmetryBreaker * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SymmetryBreaker * > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__AddRange(arg1,(std::vector< operations_research::SymmetryBreaker * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_GetRange___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< operations_research::SymmetryBreaker * > *result = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< operations_research::SymmetryBreaker * > *)std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__GetRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_Insert___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  operations_research::SymmetryBreaker **arg3 = 0 ;
  operations_research::SymmetryBreaker *temp3 = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (operations_research::SymmetryBreaker *)jarg3;
  arg3 = (operations_research::SymmetryBreaker **)&temp3; 
  try {
    std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Insert(arg1,arg2,(operations_research::SymmetryBreaker *const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_InsertRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SymmetryBreaker * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::SymmetryBreaker * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SymmetryBreaker * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__InsertRange(arg1,arg2,(std::vector< operations_research::SymmetryBreaker * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_RemoveAt___(void * jarg1, int jarg2) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__RemoveAt(arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_RemoveRange___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__RemoveRange(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_Repeat___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::SymmetryBreaker **arg1 = 0 ;
  int arg2 ;
  operations_research::SymmetryBreaker *temp1 = 0 ;
  std::vector< operations_research::SymmetryBreaker * > *result = 0 ;
  
  temp1 = (operations_research::SymmetryBreaker *)jarg1;
  arg1 = (operations_research::SymmetryBreaker **)&temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< operations_research::SymmetryBreaker * > *)std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Repeat((operations_research::SymmetryBreaker *const &)*arg1,arg2);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_Reverse__SWIG_0___(void * jarg1) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Reverse__SWIG_0(arg1);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_Reverse__SWIG_1___(void * jarg1, int jarg2, int jarg3) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  } catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_SetRange___(void * jarg1, int jarg2, void * jarg3) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  int arg2 ;
  std::vector< operations_research::SymmetryBreaker * > *arg3 = 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< operations_research::SymmetryBreaker * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SymmetryBreaker * > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__SetRange(arg1,arg2,(std::vector< operations_research::SymmetryBreaker * > const &)*arg3);
  } catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  operations_research::SymmetryBreaker **arg2 = 0 ;
  operations_research::SymmetryBreaker *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  temp2 = (operations_research::SymmetryBreaker *)jarg2;
  arg2 = (operations_research::SymmetryBreaker **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Contains(arg1,(operations_research::SymmetryBreaker *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_IndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  operations_research::SymmetryBreaker **arg2 = 0 ;
  operations_research::SymmetryBreaker *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  temp2 = (operations_research::SymmetryBreaker *)jarg2;
  arg2 = (operations_research::SymmetryBreaker **)&temp2; 
  result = (int)std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__IndexOf(arg1,(operations_research::SymmetryBreaker *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_LastIndexOf___(void * jarg1, void * jarg2) {
  int jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  operations_research::SymmetryBreaker **arg2 = 0 ;
  operations_research::SymmetryBreaker *temp2 = 0 ;
  int result;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  temp2 = (operations_research::SymmetryBreaker *)jarg2;
  arg2 = (operations_research::SymmetryBreaker **)&temp2; 
  result = (int)std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__LastIndexOf(arg1,(operations_research::SymmetryBreaker *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreakerVector_Remove___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  operations_research::SymmetryBreaker **arg2 = 0 ;
  operations_research::SymmetryBreaker *temp2 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  temp2 = (operations_research::SymmetryBreaker *)jarg2;
  arg2 = (operations_research::SymmetryBreaker **)&temp2; 
  result = (bool)std_vector_Sl_operations_research_SymmetryBreaker_Sm__Sg__Remove(arg1,(operations_research::SymmetryBreaker *const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SymmetryBreakerVector___(void * jarg1) {
  std::vector< operations_research::SymmetryBreaker * > *arg1 = (std::vector< operations_research::SymmetryBreaker * > *) 0 ;
  
  arg1 = (std::vector< operations_research::SymmetryBreaker * > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_CpRandomSeed___() {
  long long jresult ;
  int64_t result;
  
  result = (int64_t)operations_research::CpRandomSeed();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT_get___() {
  int jresult ;
  operations_research::DefaultPhaseParameters::VariableSelection result;
  
  result = (operations_research::DefaultPhaseParameters::VariableSelection)operations_research::DefaultPhaseParameters::CHOOSE_MAX_SUM_IMPACT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT_get___() {
  int jresult ;
  operations_research::DefaultPhaseParameters::VariableSelection result;
  
  result = (operations_research::DefaultPhaseParameters::VariableSelection)operations_research::DefaultPhaseParameters::CHOOSE_MAX_AVERAGE_IMPACT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT_get___() {
  int jresult ;
  operations_research::DefaultPhaseParameters::VariableSelection result;
  
  result = (operations_research::DefaultPhaseParameters::VariableSelection)operations_research::DefaultPhaseParameters::CHOOSE_MAX_VALUE_IMPACT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_SELECT_MIN_IMPACT_get___() {
  int jresult ;
  operations_research::DefaultPhaseParameters::ValueSelection result;
  
  result = (operations_research::DefaultPhaseParameters::ValueSelection)operations_research::DefaultPhaseParameters::SELECT_MIN_IMPACT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_SELECT_MAX_IMPACT_get___() {
  int jresult ;
  operations_research::DefaultPhaseParameters::ValueSelection result;
  
  result = (operations_research::DefaultPhaseParameters::ValueSelection)operations_research::DefaultPhaseParameters::SELECT_MAX_IMPACT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_NONE_get___() {
  int jresult ;
  operations_research::DefaultPhaseParameters::DisplayLevel result;
  
  result = (operations_research::DefaultPhaseParameters::DisplayLevel)operations_research::DefaultPhaseParameters::NONE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_NORMAL_get___() {
  int jresult ;
  operations_research::DefaultPhaseParameters::DisplayLevel result;
  
  result = (operations_research::DefaultPhaseParameters::DisplayLevel)operations_research::DefaultPhaseParameters::NORMAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_VERBOSE_get___() {
  int jresult ;
  operations_research::DefaultPhaseParameters::DisplayLevel result;
  
  result = (operations_research::DefaultPhaseParameters::DisplayLevel)operations_research::DefaultPhaseParameters::VERBOSE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_var_selection_schema_set___(void * jarg1, int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  operations_research::DefaultPhaseParameters::VariableSelection arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = (operations_research::DefaultPhaseParameters::VariableSelection)jarg2; 
  if (arg1) (arg1)->var_selection_schema = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_var_selection_schema_get___(void * jarg1) {
  int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  operations_research::DefaultPhaseParameters::VariableSelection result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (operations_research::DefaultPhaseParameters::VariableSelection) ((arg1)->var_selection_schema);
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_value_selection_schema_set___(void * jarg1, int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  operations_research::DefaultPhaseParameters::ValueSelection arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = (operations_research::DefaultPhaseParameters::ValueSelection)jarg2; 
  if (arg1) (arg1)->value_selection_schema = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_value_selection_schema_get___(void * jarg1) {
  int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  operations_research::DefaultPhaseParameters::ValueSelection result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (operations_research::DefaultPhaseParameters::ValueSelection) ((arg1)->value_selection_schema);
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_initialization_splits_set___(void * jarg1, int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->initialization_splits = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_initialization_splits_get___(void * jarg1) {
  int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  int result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (int) ((arg1)->initialization_splits);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_run_all_heuristics_set___(void * jarg1, unsigned int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  bool arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->run_all_heuristics = arg2;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_run_all_heuristics_get___(void * jarg1) {
  unsigned int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  bool result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (bool) ((arg1)->run_all_heuristics);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_heuristic_period_set___(void * jarg1, int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->heuristic_period = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_heuristic_period_get___(void * jarg1) {
  int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  int result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (int) ((arg1)->heuristic_period);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_heuristic_num_failures_limit_set___(void * jarg1, int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->heuristic_num_failures_limit = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_heuristic_num_failures_limit_get___(void * jarg1) {
  int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  int result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (int) ((arg1)->heuristic_num_failures_limit);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_persistent_impact_set___(void * jarg1, unsigned int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  bool arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->persistent_impact = arg2;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_persistent_impact_get___(void * jarg1) {
  unsigned int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  bool result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (bool) ((arg1)->persistent_impact);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_random_seed_set___(void * jarg1, int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->random_seed = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_random_seed_get___(void * jarg1) {
  int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  int result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (int) ((arg1)->random_seed);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_display_level_set___(void * jarg1, int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  operations_research::DefaultPhaseParameters::DisplayLevel arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = (operations_research::DefaultPhaseParameters::DisplayLevel)jarg2; 
  if (arg1) (arg1)->display_level = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_display_level_get___(void * jarg1) {
  int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  operations_research::DefaultPhaseParameters::DisplayLevel result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (operations_research::DefaultPhaseParameters::DisplayLevel) ((arg1)->display_level);
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_use_last_conflict_set___(void * jarg1, unsigned int jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  bool arg2 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->use_last_conflict = arg2;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_use_last_conflict_get___(void * jarg1) {
  unsigned int jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  bool result;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (bool) ((arg1)->use_last_conflict);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_decision_builder_set___(void * jarg1, void * jarg2) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) 0 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  if (arg1) (arg1)->decision_builder = arg2;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultPhaseParameters_decision_builder_get___(void * jarg1) {
  void * jresult ;
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  result = (operations_research::DecisionBuilder *) ((arg1)->decision_builder);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_DefaultPhaseParameters___() {
  void * jresult ;
  operations_research::DefaultPhaseParameters *result = 0 ;
  
  result = (operations_research::DefaultPhaseParameters *)new operations_research::DefaultPhaseParameters();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_DefaultPhaseParameters___(void * jarg1) {
  operations_research::DefaultPhaseParameters *arg1 = (operations_research::DefaultPhaseParameters *) 0 ;
  
  arg1 = (operations_research::DefaultPhaseParameters *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Solver_IntegerCastInfo__SWIG_0___() {
  void * jresult ;
  operations_research::Solver::IntegerCastInfo *result = 0 ;
  
  result = (operations_research::Solver::IntegerCastInfo *)new operations_research::Solver::IntegerCastInfo();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Solver_IntegerCastInfo__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::Constraint *arg3 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::Solver::IntegerCastInfo *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::Constraint *)jarg3; 
  result = (operations_research::Solver::IntegerCastInfo *)new operations_research::Solver::IntegerCastInfo(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IntegerCastInfo_variable_set___(void * jarg1, void * jarg2) {
  operations_research::Solver::IntegerCastInfo *arg1 = (operations_research::Solver::IntegerCastInfo *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  
  arg1 = (operations_research::Solver::IntegerCastInfo *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  if (arg1) (arg1)->variable = arg2;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IntegerCastInfo_variable_get___(void * jarg1) {
  void * jresult ;
  operations_research::Solver::IntegerCastInfo *arg1 = (operations_research::Solver::IntegerCastInfo *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver::IntegerCastInfo *)jarg1; 
  result = (operations_research::IntVar *) ((arg1)->variable);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IntegerCastInfo_expression_set___(void * jarg1, void * jarg2) {
  operations_research::Solver::IntegerCastInfo *arg1 = (operations_research::Solver::IntegerCastInfo *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) 0 ;
  
  arg1 = (operations_research::Solver::IntegerCastInfo *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  if (arg1) (arg1)->expression = arg2;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IntegerCastInfo_expression_get___(void * jarg1) {
  void * jresult ;
  operations_research::Solver::IntegerCastInfo *arg1 = (operations_research::Solver::IntegerCastInfo *) 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver::IntegerCastInfo *)jarg1; 
  result = (operations_research::IntExpr *) ((arg1)->expression);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IntegerCastInfo_maintainer_set___(void * jarg1, void * jarg2) {
  operations_research::Solver::IntegerCastInfo *arg1 = (operations_research::Solver::IntegerCastInfo *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) 0 ;
  
  arg1 = (operations_research::Solver::IntegerCastInfo *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  if (arg1) (arg1)->maintainer = arg2;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IntegerCastInfo_maintainer_get___(void * jarg1) {
  void * jresult ;
  operations_research::Solver::IntegerCastInfo *arg1 = (operations_research::Solver::IntegerCastInfo *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver::IntegerCastInfo *)jarg1; 
  result = (operations_research::Constraint *) ((arg1)->maintainer);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Solver_IntegerCastInfo___(void * jarg1) {
  operations_research::Solver::IntegerCastInfo *arg1 = (operations_research::Solver::IntegerCastInfo *) 0 ;
  
  arg1 = (operations_research::Solver::IntegerCastInfo *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_kNumPriorities_get___() {
  int jresult ;
  int result;
  
  result = (int)operations_research::Solver::kNumPriorities;
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INT_VAR_DEFAULT_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::INT_VAR_DEFAULT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INT_VAR_SIMPLE_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::INT_VAR_SIMPLE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_FIRST_UNBOUND_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_FIRST_UNBOUND;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_RANDOM_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_RANDOM;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_MIN_SIZE_LOWEST_MIN_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_MIN_SIZE_LOWEST_MIN;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_MIN_SIZE_HIGHEST_MIN;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_MIN_SIZE_LOWEST_MAX_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_MIN_SIZE_LOWEST_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_MIN_SIZE_HIGHEST_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_LOWEST_MIN_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_LOWEST_MIN;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_HIGHEST_MAX_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_HIGHEST_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_MIN_SIZE_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_MIN_SIZE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_MAX_SIZE_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_MAX_SIZE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_MAX_REGRET_ON_MIN_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_MAX_REGRET_ON_MIN;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_PATH_get___() {
  int jresult ;
  operations_research::Solver::IntVarStrategy result;
  
  result = (operations_research::Solver::IntVarStrategy)operations_research::Solver::CHOOSE_PATH;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INT_VALUE_DEFAULT_get___() {
  int jresult ;
  operations_research::Solver::IntValueStrategy result;
  
  result = (operations_research::Solver::IntValueStrategy)operations_research::Solver::INT_VALUE_DEFAULT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INT_VALUE_SIMPLE_get___() {
  int jresult ;
  operations_research::Solver::IntValueStrategy result;
  
  result = (operations_research::Solver::IntValueStrategy)operations_research::Solver::INT_VALUE_SIMPLE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ASSIGN_MIN_VALUE_get___() {
  int jresult ;
  operations_research::Solver::IntValueStrategy result;
  
  result = (operations_research::Solver::IntValueStrategy)operations_research::Solver::ASSIGN_MIN_VALUE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ASSIGN_MAX_VALUE_get___() {
  int jresult ;
  operations_research::Solver::IntValueStrategy result;
  
  result = (operations_research::Solver::IntValueStrategy)operations_research::Solver::ASSIGN_MAX_VALUE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ASSIGN_RANDOM_VALUE_get___() {
  int jresult ;
  operations_research::Solver::IntValueStrategy result;
  
  result = (operations_research::Solver::IntValueStrategy)operations_research::Solver::ASSIGN_RANDOM_VALUE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ASSIGN_CENTER_VALUE_get___() {
  int jresult ;
  operations_research::Solver::IntValueStrategy result;
  
  result = (operations_research::Solver::IntValueStrategy)operations_research::Solver::ASSIGN_CENTER_VALUE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SPLIT_LOWER_HALF_get___() {
  int jresult ;
  operations_research::Solver::IntValueStrategy result;
  
  result = (operations_research::Solver::IntValueStrategy)operations_research::Solver::SPLIT_LOWER_HALF;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SPLIT_UPPER_HALF_get___() {
  int jresult ;
  operations_research::Solver::IntValueStrategy result;
  
  result = (operations_research::Solver::IntValueStrategy)operations_research::Solver::SPLIT_UPPER_HALF;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_STATIC_GLOBAL_BEST_get___() {
  int jresult ;
  operations_research::Solver::EvaluatorStrategy result;
  
  result = (operations_research::Solver::EvaluatorStrategy)operations_research::Solver::CHOOSE_STATIC_GLOBAL_BEST;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_DYNAMIC_GLOBAL_BEST_get___() {
  int jresult ;
  operations_research::Solver::EvaluatorStrategy result;
  
  result = (operations_research::Solver::EvaluatorStrategy)operations_research::Solver::CHOOSE_DYNAMIC_GLOBAL_BEST;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SEQUENCE_DEFAULT_get___() {
  int jresult ;
  operations_research::Solver::SequenceStrategy result;
  
  result = (operations_research::Solver::SequenceStrategy)operations_research::Solver::SEQUENCE_DEFAULT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SEQUENCE_SIMPLE_get___() {
  int jresult ;
  operations_research::Solver::SequenceStrategy result;
  
  result = (operations_research::Solver::SequenceStrategy)operations_research::Solver::SEQUENCE_SIMPLE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_MIN_SLACK_RANK_FORWARD_get___() {
  int jresult ;
  operations_research::Solver::SequenceStrategy result;
  
  result = (operations_research::Solver::SequenceStrategy)operations_research::Solver::CHOOSE_MIN_SLACK_RANK_FORWARD;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOOSE_RANDOM_RANK_FORWARD_get___() {
  int jresult ;
  operations_research::Solver::SequenceStrategy result;
  
  result = (operations_research::Solver::SequenceStrategy)operations_research::Solver::CHOOSE_RANDOM_RANK_FORWARD;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INTERVAL_DEFAULT_get___() {
  int jresult ;
  operations_research::Solver::IntervalStrategy result;
  
  result = (operations_research::Solver::IntervalStrategy)operations_research::Solver::INTERVAL_DEFAULT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INTERVAL_SIMPLE_get___() {
  int jresult ;
  operations_research::Solver::IntervalStrategy result;
  
  result = (operations_research::Solver::IntervalStrategy)operations_research::Solver::INTERVAL_SIMPLE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INTERVAL_SET_TIMES_FORWARD_get___() {
  int jresult ;
  operations_research::Solver::IntervalStrategy result;
  
  result = (operations_research::Solver::IntervalStrategy)operations_research::Solver::INTERVAL_SET_TIMES_FORWARD;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INTERVAL_SET_TIMES_BACKWARD_get___() {
  int jresult ;
  operations_research::Solver::IntervalStrategy result;
  
  result = (operations_research::Solver::IntervalStrategy)operations_research::Solver::INTERVAL_SET_TIMES_BACKWARD;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_TWOOPT_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::TWOOPT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_OROPT_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::OROPT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RELOCATE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::RELOCATE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_EXCHANGE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::EXCHANGE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CROSS_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::CROSS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MAKEACTIVE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::MAKEACTIVE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MAKEINACTIVE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::MAKEINACTIVE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MAKECHAININACTIVE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::MAKECHAININACTIVE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SWAPACTIVE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::SWAPACTIVE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_EXTENDEDSWAPACTIVE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::EXTENDEDSWAPACTIVE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_PATHLNS_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::PATHLNS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_FULLPATHLNS_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::FULLPATHLNS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_UNACTIVELNS_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::UNACTIVELNS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_INCREMENT_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::INCREMENT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_DECREMENT_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::DECREMENT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SIMPLELNS_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchOperators result;
  
  result = (operations_research::Solver::LocalSearchOperators)operations_research::Solver::SIMPLELNS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_LK_get___() {
  int jresult ;
  operations_research::Solver::EvaluatorLocalSearchOperators result;
  
  result = (operations_research::Solver::EvaluatorLocalSearchOperators)operations_research::Solver::LK;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_TSPOPT_get___() {
  int jresult ;
  operations_research::Solver::EvaluatorLocalSearchOperators result;
  
  result = (operations_research::Solver::EvaluatorLocalSearchOperators)operations_research::Solver::TSPOPT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_TSPLNS_get___() {
  int jresult ;
  operations_research::Solver::EvaluatorLocalSearchOperators result;
  
  result = (operations_research::Solver::EvaluatorLocalSearchOperators)operations_research::Solver::TSPLNS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_GE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchFilterBound result;
  
  result = (operations_research::Solver::LocalSearchFilterBound)operations_research::Solver::GE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_LE_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchFilterBound result;
  
  result = (operations_research::Solver::LocalSearchFilterBound)operations_research::Solver::LE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_EQ_get___() {
  int jresult ;
  operations_research::Solver::LocalSearchFilterBound result;
  
  result = (operations_research::Solver::LocalSearchFilterBound)operations_research::Solver::EQ;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_DELAYED_PRIORITY_get___() {
  int jresult ;
  operations_research::Solver::DemonPriority result;
  
  result = (operations_research::Solver::DemonPriority)operations_research::Solver::DELAYED_PRIORITY;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_VAR_PRIORITY_get___() {
  int jresult ;
  operations_research::Solver::DemonPriority result;
  
  result = (operations_research::Solver::DemonPriority)operations_research::Solver::VAR_PRIORITY;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NORMAL_PRIORITY_get___() {
  int jresult ;
  operations_research::Solver::DemonPriority result;
  
  result = (operations_research::Solver::DemonPriority)operations_research::Solver::NORMAL_PRIORITY;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ENDS_AFTER_END_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::ENDS_AFTER_END;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ENDS_AFTER_START_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::ENDS_AFTER_START;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ENDS_AT_END_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::ENDS_AT_END;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ENDS_AT_START_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::ENDS_AT_START;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_STARTS_AFTER_END_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::STARTS_AFTER_END;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_STARTS_AFTER_START_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::STARTS_AFTER_START;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_STARTS_AT_END_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::STARTS_AT_END;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_STARTS_AT_START_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::STARTS_AT_START;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_STAYS_IN_SYNC_get___() {
  int jresult ;
  operations_research::Solver::BinaryIntervalRelation result;
  
  result = (operations_research::Solver::BinaryIntervalRelation)operations_research::Solver::STAYS_IN_SYNC;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ENDS_AFTER_get___() {
  int jresult ;
  operations_research::Solver::UnaryIntervalRelation result;
  
  result = (operations_research::Solver::UnaryIntervalRelation)operations_research::Solver::ENDS_AFTER;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ENDS_AT_get___() {
  int jresult ;
  operations_research::Solver::UnaryIntervalRelation result;
  
  result = (operations_research::Solver::UnaryIntervalRelation)operations_research::Solver::ENDS_AT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ENDS_BEFORE_get___() {
  int jresult ;
  operations_research::Solver::UnaryIntervalRelation result;
  
  result = (operations_research::Solver::UnaryIntervalRelation)operations_research::Solver::ENDS_BEFORE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_STARTS_AFTER_get___() {
  int jresult ;
  operations_research::Solver::UnaryIntervalRelation result;
  
  result = (operations_research::Solver::UnaryIntervalRelation)operations_research::Solver::STARTS_AFTER;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_STARTS_AT_get___() {
  int jresult ;
  operations_research::Solver::UnaryIntervalRelation result;
  
  result = (operations_research::Solver::UnaryIntervalRelation)operations_research::Solver::STARTS_AT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_STARTS_BEFORE_get___() {
  int jresult ;
  operations_research::Solver::UnaryIntervalRelation result;
  
  result = (operations_research::Solver::UnaryIntervalRelation)operations_research::Solver::STARTS_BEFORE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CROSS_DATE_get___() {
  int jresult ;
  operations_research::Solver::UnaryIntervalRelation result;
  
  result = (operations_research::Solver::UnaryIntervalRelation)operations_research::Solver::CROSS_DATE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_AVOID_DATE_get___() {
  int jresult ;
  operations_research::Solver::UnaryIntervalRelation result;
  
  result = (operations_research::Solver::UnaryIntervalRelation)operations_research::Solver::AVOID_DATE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NO_CHANGE_get___() {
  int jresult ;
  operations_research::Solver::DecisionModification result;
  
  result = (operations_research::Solver::DecisionModification)operations_research::Solver::NO_CHANGE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_KEEP_LEFT_get___() {
  int jresult ;
  operations_research::Solver::DecisionModification result;
  
  result = (operations_research::Solver::DecisionModification)operations_research::Solver::KEEP_LEFT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_KEEP_RIGHT_get___() {
  int jresult ;
  operations_research::Solver::DecisionModification result;
  
  result = (operations_research::Solver::DecisionModification)operations_research::Solver::KEEP_RIGHT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_KILL_BOTH_get___() {
  int jresult ;
  operations_research::Solver::DecisionModification result;
  
  result = (operations_research::Solver::DecisionModification)operations_research::Solver::KILL_BOTH;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SWITCH_BRANCHES_get___() {
  int jresult ;
  operations_research::Solver::DecisionModification result;
  
  result = (operations_research::Solver::DecisionModification)operations_research::Solver::SWITCH_BRANCHES;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SENTINEL_get___() {
  int jresult ;
  operations_research::Solver::MarkerType result;
  
  result = (operations_research::Solver::MarkerType)operations_research::Solver::SENTINEL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SIMPLE_MARKER_get___() {
  int jresult ;
  operations_research::Solver::MarkerType result;
  
  result = (operations_research::Solver::MarkerType)operations_research::Solver::SIMPLE_MARKER;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CHOICE_POINT_get___() {
  int jresult ;
  operations_research::Solver::MarkerType result;
  
  result = (operations_research::Solver::MarkerType)operations_research::Solver::CHOICE_POINT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_REVERSIBLE_ACTION_get___() {
  int jresult ;
  operations_research::Solver::MarkerType result;
  
  result = (operations_research::Solver::MarkerType)operations_research::Solver::REVERSIBLE_ACTION;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_OUTSIDE_SEARCH_get___() {
  int jresult ;
  operations_research::Solver::SolverState result;
  
  result = (operations_research::Solver::SolverState)operations_research::Solver::OUTSIDE_SEARCH;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IN_ROOT_NODE_get___() {
  int jresult ;
  operations_research::Solver::SolverState result;
  
  result = (operations_research::Solver::SolverState)operations_research::Solver::IN_ROOT_NODE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IN_SEARCH_get___() {
  int jresult ;
  operations_research::Solver::SolverState result;
  
  result = (operations_research::Solver::SolverState)operations_research::Solver::IN_SEARCH;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_AT_SOLUTION_get___() {
  int jresult ;
  operations_research::Solver::SolverState result;
  
  result = (operations_research::Solver::SolverState)operations_research::Solver::AT_SOLUTION;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NO_MORE_SOLUTIONS_get___() {
  int jresult ;
  operations_research::Solver::SolverState result;
  
  result = (operations_research::Solver::SolverState)operations_research::Solver::NO_MORE_SOLUTIONS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_PROBLEM_INFEASIBLE_get___() {
  int jresult ;
  operations_research::Solver::SolverState result;
  
  result = (operations_research::Solver::SolverState)operations_research::Solver::PROBLEM_INFEASIBLE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NOT_SET_get___() {
  int jresult ;
  operations_research::Solver::OptimizationDirection result;
  
  result = (operations_research::Solver::OptimizationDirection)operations_research::Solver::NOT_SET;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MAXIMIZATION_get___() {
  int jresult ;
  operations_research::Solver::OptimizationDirection result;
  
  result = (operations_research::Solver::OptimizationDirection)operations_research::Solver::MAXIMIZATION;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MINIMIZATION_get___() {
  int jresult ;
  operations_research::Solver::OptimizationDirection result;
  
  result = (operations_research::Solver::OptimizationDirection)operations_research::Solver::MINIMIZATION;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Solver__SWIG_0___(char * jarg1) {
  void * jresult ;
  std::string *arg1 = 0 ;
  operations_research::Solver *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  result = (operations_research::Solver *)new operations_research::Solver((std::string const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Solver__SWIG_1___(char * jarg1, int parameters_size, uint8_t* jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  operations_research::ConstraintSolverParameters *arg2 = 0 ;
  operations_research::Solver *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  {
    arg2 = new operations_research::ConstraintSolverParameters;
    bool parsed_ok = arg2->ParseFromArray(jarg2, parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::ConstraintSolverParameters protocol message.");
    }
  }
  result = (operations_research::Solver *)new operations_research::Solver((std::string const &)*arg1,(operations_research::ConstraintSolverParameters const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2;
  }
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Solver___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT uint8_t* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Parameters___(void * jarg1) {
  uint8_t* jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::ConstraintSolverParameters result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = ((operations_research::Solver const *)arg1)->parameters();
  {
    const long size = (&result)->ByteSizeLong();
    jresult = new uint8_t[size + 4];
    (&result)->SerializeWithCachedSizesToArray(jresult + 4);
    jresult[0] = size & 0xFF;
    jresult[1] = (size >> 8) & 0xFF;
    jresult[2] = (size >> 16) & 0xFF;
    jresult[3] = (size >> 24) & 0xFF;
  }
  return jresult;
}
 
 
SWIGEXPORT uint8_t* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_DefaultSolverParameters___() {
  uint8_t* jresult ;
  operations_research::ConstraintSolverParameters result;
  
  result = operations_research::Solver::DefaultSolverParameters();
  {
    const long size = (&result)->ByteSizeLong();
    jresult = new uint8_t[size + 4];
    (&result)->SerializeWithCachedSizesToArray(jresult + 4);
    jresult[0] = size & 0xFF;
    jresult[1] = (size >> 8) & 0xFF;
    jresult[2] = (size >> 16) & 0xFF;
    jresult[3] = (size >> 24) & 0xFF;
  }
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Add___(void * jarg1, void * jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  {
    operations_research::Solver* const solver = arg1;
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->AddConstraint(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_AddCastConstraint___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::CastConstraint *arg2 = (operations_research::CastConstraint *) (operations_research::CastConstraint *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *arg4 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::CastConstraint *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (operations_research::IntExpr *)jarg4; 
  (arg1)->AddCastConstraint(arg2,arg3,arg4);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Solve__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  std::vector< operations_research::SearchMonitor * > *arg3 = 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (std::vector< operations_research::SearchMonitor * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return 0;
  } 
  result = (bool)(arg1)->Solve(arg2,(std::vector< operations_research::SearchMonitor * > const &)*arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Solve__SWIG_1___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  result = (bool)(arg1)->Solve(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Solve__SWIG_2___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  result = (bool)(arg1)->Solve(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Solve__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  result = (bool)(arg1)->Solve(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Solve__SWIG_4___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg5 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  arg5 = (operations_research::SearchMonitor *)jarg5; 
  result = (bool)(arg1)->Solve(arg2,arg3,arg4,arg5);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Solve__SWIG_5___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg5 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg6 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  arg5 = (operations_research::SearchMonitor *)jarg5; 
  arg6 = (operations_research::SearchMonitor *)jarg6; 
  result = (bool)(arg1)->Solve(arg2,arg3,arg4,arg5,arg6);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NewSearchAux__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  std::vector< operations_research::SearchMonitor * > *arg3 = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (std::vector< operations_research::SearchMonitor * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return ;
  } 
  (arg1)->NewSearch(arg2,(std::vector< operations_research::SearchMonitor * > const &)*arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NewSearchAux__SWIG_1___(void * jarg1, void * jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  (arg1)->NewSearch(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NewSearchAux__SWIG_2___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  (arg1)->NewSearch(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NewSearchAux__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  (arg1)->NewSearch(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NewSearchAux__SWIG_4___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg5 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  arg5 = (operations_research::SearchMonitor *)jarg5; 
  (arg1)->NewSearch(arg2,arg3,arg4,arg5);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NewSearchAux__SWIG_5___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg5 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg6 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  arg5 = (operations_research::SearchMonitor *)jarg5; 
  arg6 = (operations_research::SearchMonitor *)jarg6; 
  (arg1)->NewSearch(arg2,arg3,arg4,arg5,arg6);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NextSolution___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (bool)(arg1)->NextSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RestartSearch___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->RestartSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_EndSearchAux___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->EndSearch();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SolveAndCommit__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  std::vector< operations_research::SearchMonitor * > *arg3 = 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (std::vector< operations_research::SearchMonitor * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return 0;
  } 
  result = (bool)(arg1)->SolveAndCommit(arg2,(std::vector< operations_research::SearchMonitor * > const &)*arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SolveAndCommit__SWIG_1___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  result = (bool)(arg1)->SolveAndCommit(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SolveAndCommit__SWIG_2___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  result = (bool)(arg1)->SolveAndCommit(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SolveAndCommit__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  result = (bool)(arg1)->SolveAndCommit(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SolveAndCommit__SWIG_4___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg5 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  arg5 = (operations_research::SearchMonitor *)jarg5; 
  result = (bool)(arg1)->SolveAndCommit(arg2,arg3,arg4,arg5);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CheckAssignment___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (bool)(arg1)->CheckAssignment(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CheckConstraint___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  result = (bool)(arg1)->CheckConstraint(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_State___(void * jarg1) {
  int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Solver::SolverState result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Solver::SolverState)((operations_research::Solver const *)arg1)->state();
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Fail___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  {
    operations_research::Solver* const solver = arg1;
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->Fail();
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = ((operations_research::Solver const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MemoryUsage___() {
  long long jresult ;
  int64_t result;
  
  result = (int64_t)operations_research::Solver::MemoryUsage();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_WallTime___(void * jarg1) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int64_t)((operations_research::Solver const *)arg1)->wall_time();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Branches___(void * jarg1) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int64_t)((operations_research::Solver const *)arg1)->branches();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Solutions___(void * jarg1) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int64_t)((operations_research::Solver const *)arg1)->solutions();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_UncheckedSolutions___(void * jarg1) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int64_t)((operations_research::Solver const *)arg1)->unchecked_solutions();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_DemonRuns___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Solver::DemonPriority arg2 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Solver::DemonPriority)jarg2; 
  result = (int64_t)((operations_research::Solver const *)arg1)->demon_runs(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Failures___(void * jarg1) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int64_t)((operations_research::Solver const *)arg1)->failures();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Neighbors___(void * jarg1) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int64_t)((operations_research::Solver const *)arg1)->neighbors();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_FilteredNeighbors___(void * jarg1) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int64_t)((operations_research::Solver const *)arg1)->filtered_neighbors();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_AcceptedNeighbors___(void * jarg1) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int64_t)((operations_research::Solver const *)arg1)->accepted_neighbors();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Stamp___(void * jarg1) {
  unsigned long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  uint64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (uint64_t)((operations_research::Solver const *)arg1)->stamp();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_FailStamp___(void * jarg1) {
  unsigned long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  uint64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (uint64_t)((operations_research::Solver const *)arg1)->fail_stamp();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SetOptimizationDirection___(void * jarg1, int jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Solver::OptimizationDirection arg2 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Solver::OptimizationDirection)jarg2; 
  (arg1)->set_optimization_direction(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntVar__SWIG_0___(void * jarg1, long long jarg2, long long jarg3, char * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  std::string *arg4 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  result = (operations_research::IntVar *)(arg1)->MakeIntVar(arg2,arg3,(std::string const &)*arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntVar__SWIG_1___(void * jarg1,  int length2, int64_t*  jarg2, char * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  result = (operations_research::IntVar *)(arg1)->MakeIntVar((std::vector< int64_t > const &)*arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntVar__SWIG_2___(void * jarg1,  int length2, int*  jarg2, char * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< int > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  result = (operations_research::IntVar *)(arg1)->MakeIntVar((std::vector< int > const &)*arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntVar__SWIG_3___(void * jarg1, long long jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIntVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntVar__SWIG_4___(void * jarg1,  int length2, int64_t*  jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (operations_research::IntVar *)(arg1)->MakeIntVar((std::vector< int64_t > const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntVar__SWIG_5___(void * jarg1,  int length2, int*  jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< int > *arg2 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (operations_research::IntVar *)(arg1)->MakeIntVar((std::vector< int > const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeBoolVar__SWIG_0___(void * jarg1, char * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (operations_research::IntVar *)(arg1)->MakeBoolVar((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeBoolVar__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::IntVar *)(arg1)->MakeBoolVar();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntConst__SWIG_0___(void * jarg1, long long jarg2, char * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  std::string *arg3 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  result = (operations_research::IntVar *)(arg1)->MakeIntConst(arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntConst__SWIG_1___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->MakeIntConst(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSum__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeSum(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSum__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeSum(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSum__SWIG_2___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::IntExpr *)(arg1)->MakeSum((std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProd__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::IntExpr *)(arg1)->MakeScalProd((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProd__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::IntExpr *)(arg1)->MakeScalProd((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDifference__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeDifference(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDifference__SWIG_1___(void * jarg1, long long jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeDifference(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeOpposite___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntExpr *)(arg1)->MakeOpposite(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeProd__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeProd(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeProd__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeProd(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDiv__SWIG_0___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeDiv(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDiv__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeDiv(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAbs___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntExpr *)(arg1)->MakeAbs(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSquare___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntExpr *)(arg1)->MakeSquare(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePower___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakePower(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElement__SWIG_0___(void * jarg1,  int length2, int64_t*  jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeElement((std::vector< int64_t > const &)*arg2,arg3);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElement__SWIG_1___(void * jarg1,  int length2, int*  jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< int > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeElement((std::vector< int > const &)*arg2,arg3);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElement__SWIG_2___(void * jarg1,  void *  jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Solver::IndexEvaluator1 arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg2)(t);
  };
  
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeElement(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMonotonicElement___(void * jarg1,  void *  jarg2, unsigned int jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Solver::IndexEvaluator1 arg2 ;
  bool arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg2)(t);
  };
  
  arg3 = jarg3 ? true : false; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::IntExpr *)(arg1)->MakeMonotonicElement(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElement__SWIG_3___(void * jarg1,  void *  jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Solver::IndexEvaluator2 arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg2)(t, u);
  };
  
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::IntExpr *)(arg1)->MakeElement(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElement__SWIG_4___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeElement((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIndexExpression___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeIndexExpression((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIfThenElseCt___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg4 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *arg5 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntExpr *)jarg4; 
  arg5 = (operations_research::IntVar *)jarg5; 
  result = (operations_research::Constraint *)(arg1)->MakeIfThenElseCt(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMin__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::IntExpr *)(arg1)->MakeMin((std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMin__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeMin(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMin__SWIG_2___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeMin(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMin__SWIG_3___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeMin(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMax__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::IntExpr *)(arg1)->MakeMax((std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMax__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeMax(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMax__SWIG_2___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeMax(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMax__SWIG_3___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeMax(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeConvexPiecewiseExpr___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, long long jarg5, long long jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) 0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  int64_t arg6 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = (int64_t)jarg6; 
  result = (operations_research::IntExpr *)(arg1)->MakeConvexPiecewiseExpr(arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSemiContinuousExpr___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::IntExpr *)(arg1)->MakeSemiContinuousExpr(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeModulo__SWIG_0___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeModulo(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeModulo__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntExpr *)(arg1)->MakeModulo(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeConditionalExpression___(void * jarg1, void * jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg4 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::IntExpr *)(arg1)->MakeConditionalExpression(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeTrueConstraint___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Constraint *)(arg1)->MakeTrueConstraint();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFalseConstraint__SWIG_0___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Constraint *)(arg1)->MakeFalseConstraint();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFalseConstraint__SWIG_1___(void * jarg1, char * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (operations_research::Constraint *)(arg1)->MakeFalseConstraint((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsEqualCstCt___(void * jarg1, void * jarg2, long long jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsEqualCstCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsEqualCstVar___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsEqualCstVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsEqualCt___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) 0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsEqualCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsEqualVar___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsEqualVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeEquality__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeEquality(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeEquality__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeEquality(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeEquality__SWIG_2___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeEquality(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsDifferentCstCt___(void * jarg1, void * jarg2, long long jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsDifferentCstCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsDifferentCstVar___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsDifferentCstVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsDifferentVar___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsDifferentVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsDifferentCt___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsDifferentCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonEquality__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeNonEquality(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonEquality__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeNonEquality(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonEquality__SWIG_2___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeNonEquality(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsLessOrEqualCstCt___(void * jarg1, void * jarg2, long long jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsLessOrEqualCstCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsLessOrEqualCstVar___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsLessOrEqualCstVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsLessOrEqualVar___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsLessOrEqualVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsLessOrEqualCt___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsLessOrEqualCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLessOrEqual__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeLessOrEqual(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLessOrEqual__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeLessOrEqual(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLessOrEqual__SWIG_2___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeLessOrEqual(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsGreaterOrEqualCstCt___(void * jarg1, void * jarg2, long long jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsGreaterOrEqualCstCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsGreaterOrEqualCstVar___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsGreaterOrEqualCstVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsGreaterOrEqualVar___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsGreaterOrEqualVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsGreaterOrEqualCt___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsGreaterOrEqualCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGreaterOrEqual__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeGreaterOrEqual(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGreaterOrEqual__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeGreaterOrEqual(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGreaterOrEqual__SWIG_2___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeGreaterOrEqual(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsGreaterCstCt___(void * jarg1, void * jarg2, long long jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsGreaterCstCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsGreaterCstVar___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsGreaterCstVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsGreaterVar___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsGreaterVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsGreaterCt___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsGreaterCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGreater__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeGreater(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGreater__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeGreater(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGreater__SWIG_2___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeGreater(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsLessCstCt___(void * jarg1, void * jarg2, long long jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsLessCstCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsLessCstVar___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsLessCstVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsLessVar___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::IntVar *)(arg1)->MakeIsLessVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsLessCt___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsLessCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLess__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeLess(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLess__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeLess(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLess__SWIG_2___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeLess(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSumLessOrEqual___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeSumLessOrEqual((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSumGreaterOrEqual___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeSumGreaterOrEqual((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSumEquality__SWIG_0___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeSumEquality((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSumEquality__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeSumEquality((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProdEquality__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeScalProdEquality((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProdEquality__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeScalProdEquality((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProdEquality__SWIG_2___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeScalProdEquality((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProdEquality__SWIG_3___(void * jarg1, void * jarg2,  int length3, int*  jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeScalProdEquality((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProdGreaterOrEqual__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeScalProdGreaterOrEqual((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProdGreaterOrEqual__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeScalProdGreaterOrEqual((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProdLessOrEqual__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeScalProdLessOrEqual((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScalProdLessOrEqual__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeScalProdLessOrEqual((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMinEquality___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeMinEquality((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMaxEquality___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeMaxEquality((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElementEquality__SWIG_0___(void * jarg1,  int length2, int64_t*  jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeElementEquality((std::vector< int64_t > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElementEquality__SWIG_1___(void * jarg1,  int length2, int*  jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< int > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeElementEquality((std::vector< int > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElementEquality__SWIG_2___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeElementEquality((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeElementEquality__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeElementEquality((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAbsEquality___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeAbsEquality(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIndexOfConstraint___(void * jarg1, void * jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIndexOfConstraint((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeConstraintInitialPropagateCallback___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::Demon *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  result = (operations_research::Demon *)(arg1)->MakeConstraintInitialPropagateCallback(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDelayedConstraintInitialPropagateCallback___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::Demon *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  result = (operations_research::Demon *)(arg1)->MakeDelayedConstraintInitialPropagateCallback(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeClosureDemon___(void * jarg1,  void *  jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Solver::Closure arg2 ;
  operations_research::Demon *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  result = (operations_research::Demon *)(arg1)->MakeClosureDemon(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeBetweenCt___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeBetweenCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNotBetweenCt___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeNotBetweenCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsBetweenCt___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::IntVar *arg5 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::IntVar *)jarg5; 
  result = (operations_research::Constraint *)(arg1)->MakeIsBetweenCt(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsBetweenVar___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::IntVar *)(arg1)->MakeIsBetweenVar(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMemberCt__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeMemberCt(arg2,(std::vector< int64_t > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMemberCt__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeMemberCt(arg2,(std::vector< int > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNotMemberCt__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeNotMemberCt(arg2,(std::vector< int64_t > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNotMemberCt__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeNotMemberCt(arg2,(std::vector< int > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNotMemberCt__SWIG_2___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3,  int length4, int64_t*  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int64_t > arg3 ;
  std::vector< int64_t > arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  (&arg3)->clear();
  (&arg3)->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    (&arg3)->emplace_back(jarg3[i]);
  }
  
  
  (&arg4)->clear();
  (&arg4)->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    (&arg4)->emplace_back(jarg4[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeNotMemberCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNotMemberCt__SWIG_3___(void * jarg1, void * jarg2,  int length3, int*  jarg3,  int length4, int*  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int > arg3 ;
  std::vector< int > arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  (&arg3)->clear();
  (&arg3)->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    (&arg3)->emplace_back(jarg3[i]);
  }
  
  
  (&arg4)->clear();
  (&arg4)->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    (&arg4)->emplace_back(jarg4[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeNotMemberCt(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsMemberCt__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsMemberCt(arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsMemberCt__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int > *arg3 = 0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIsMemberCt(arg2,(std::vector< int > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsMemberVar__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::IntVar *)(arg1)->MakeIsMemberVar(arg2,(std::vector< int64_t > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIsMemberVar__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< int > *arg3 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::IntVar *)(arg1)->MakeIsMemberVar(arg2,(std::vector< int > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCount__SWIG_0___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeCount((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCount__SWIG_1___(void * jarg1, void * jarg2, long long jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeCount((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDistribute__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeDistribute((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,(std::vector< operations_research::IntVar * > const &)*arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDistribute__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeDistribute((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,(std::vector< operations_research::IntVar * > const &)*arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDistribute__SWIG_2___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeDistribute((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDistribute__SWIG_3___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, long long jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  result = (operations_research::Constraint *)(arg1)->MakeDistribute((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDistribute__SWIG_4___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3,  int length4, int64_t*  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  std::vector< int64_t > *arg4 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<int64_t>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeDistribute((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,(std::vector< int64_t > const &)*arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDistribute__SWIG_5___(void * jarg1, void * jarg2,  int length3, int*  jarg3,  int length4, int*  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeDistribute((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,(std::vector< int > const &)*arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDistribute__SWIG_6___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3,  int length4, int64_t*  jarg4,  int length5, int64_t*  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  std::vector< int64_t > *arg4 = 0 ;
  std::vector< int64_t > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<int64_t>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  
  arg5 = new std::vector<int64_t>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeDistribute((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,(std::vector< int64_t > const &)*arg4,(std::vector< int64_t > const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
  {
    delete arg5; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDistribute__SWIG_7___(void * jarg1, void * jarg2,  int length3, int*  jarg3,  int length4, int*  jarg4,  int length5, int*  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  std::vector< int > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  
  arg5 = new std::vector<int>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeDistribute((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,(std::vector< int > const &)*arg4,(std::vector< int > const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
  {
    delete arg5; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDeviation___(void * jarg1, void * jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeDeviation((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAllDifferent__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeAllDifferent((std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAllDifferent__SWIG_1___(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  bool arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  result = (operations_research::Constraint *)(arg1)->MakeAllDifferent((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAllDifferentExcept___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeAllDifferentExcept((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSortingConstraint___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeSortingConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLexicalLess___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeLexicalLess((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLexicalLessOrEqual___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeLexicalLessOrEqual((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeInversePermutationConstraint___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeInversePermutationConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIndexOfFirstMaxValueConstraint___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeIndexOfFirstMaxValueConstraint(arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIndexOfFirstMinValueConstraint___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeIndexOfFirstMinValueConstraint(arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNullIntersect___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeNullIntersect((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNullIntersectExcept___(void * jarg1, void * jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeNullIntersectExcept((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNoCycle__SWIG_0___(void * jarg1, void * jarg2, void * jarg3,  void *  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Solver::IndexFilter1 arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = [jarg4](int64_t t) -> bool {
    return (*(bool(*)(int64_t))jarg4)(t);
  };
  
  result = (operations_research::Constraint *)(arg1)->MakeNoCycle((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNoCycle__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeNoCycle((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNoCycle__SWIG_2___(void * jarg1, void * jarg2, void * jarg3,  void *  jarg4, unsigned int jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Solver::IndexFilter1 arg4 ;
  bool arg5 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = [jarg4](int64_t t) -> bool {
    return (*(bool(*)(int64_t))jarg4)(t);
  };
  
  arg5 = jarg5 ? true : false; 
  result = (operations_research::Constraint *)(arg1)->MakeNoCycle((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCircuit___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeCircuit((std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSubCircuit___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeSubCircuit((std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePathCumul__SWIG_0___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  std::vector< operations_research::IntVar * > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< operations_research::IntVar * > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakePathCumul((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< operations_research::IntVar * > const &)*arg4,(std::vector< operations_research::IntVar * > const &)*arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDelayedPathCumul___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  std::vector< operations_research::IntVar * > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< operations_research::IntVar * > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeDelayedPathCumul((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< operations_research::IntVar * > const &)*arg4,(std::vector< operations_research::IntVar * > const &)*arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePathCumul__SWIG_1___(void * jarg1, void * jarg2, void * jarg3, void * jarg4,  void *  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  operations_research::Solver::IndexEvaluator2 arg5 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg5 = [jarg5](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg5)(t, u);
  };
  
  result = (operations_research::Constraint *)(arg1)->MakePathCumul((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< operations_research::IntVar * > const &)*arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePathCumul__SWIG_2___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5,  void *  jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  std::vector< operations_research::IntVar * > *arg5 = 0 ;
  operations_research::Solver::IndexEvaluator2 arg6 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< operations_research::IntVar * > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg6 = [jarg6](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg6)(t, u);
  };
  
  result = (operations_research::Constraint *)(arg1)->MakePathCumul((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< operations_research::IntVar * > const &)*arg4,(std::vector< operations_research::IntVar * > const &)*arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePathConnected___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3,  int length4, int64_t*  jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > arg2 ;
  std::vector< int64_t > arg3 ;
  std::vector< int64_t > arg4 ;
  std::vector< operations_research::IntVar * > arg5 ;
  std::vector< operations_research::IntVar * > *argp2 ;
  std::vector< operations_research::IntVar * > *argp5 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  argp2 = (std::vector< operations_research::IntVar * > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::IntVar * >", 0);
    return 0;
  }
  arg2 = *argp2; 
  
  (&arg3)->clear();
  (&arg3)->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    (&arg3)->emplace_back(jarg3[i]);
  }
  
  
  (&arg4)->clear();
  (&arg4)->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    (&arg4)->emplace_back(jarg4[i]);
  }
  
  argp5 = (std::vector< operations_research::IntVar * > *)jarg5; 
  if (!argp5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::IntVar * >", 0);
    return 0;
  }
  arg5 = *argp5; 
  result = (operations_research::Constraint *)(arg1)->MakePathConnected(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMapDomain___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeMapDomain(arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAllowedAssignments___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntTupleSet *arg3 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntTupleSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::IntTupleSet const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeAllowedAssignments((std::vector< operations_research::IntVar * > const &)*arg2,(operations_research::IntTupleSet const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeTransitionConstraint__SWIG_0___(void * jarg1, void * jarg2, void * jarg3, long long jarg4,  int length5, int64_t*  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntTupleSet *arg3 = 0 ;
  int64_t arg4 ;
  std::vector< int64_t > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntTupleSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::IntTupleSet const & type is null", 0);
    return 0;
  } 
  arg4 = (int64_t)jarg4; 
  
  arg5 = new std::vector<int64_t>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeTransitionConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(operations_research::IntTupleSet const &)*arg3,arg4,(std::vector< int64_t > const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg5; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeTransitionConstraint__SWIG_1___(void * jarg1, void * jarg2, void * jarg3, long long jarg4,  int length5, int*  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntTupleSet *arg3 = 0 ;
  int64_t arg4 ;
  std::vector< int > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntTupleSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::IntTupleSet const & type is null", 0);
    return 0;
  } 
  arg4 = (int64_t)jarg4; 
  
  arg5 = new std::vector<int>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeTransitionConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(operations_research::IntTupleSet const &)*arg3,arg4,(std::vector< int > const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg5; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonOverlappingBoxesConstraint__SWIG_0___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  std::vector< operations_research::IntVar * > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< operations_research::IntVar * > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeNonOverlappingBoxesConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< operations_research::IntVar * > const &)*arg4,(std::vector< operations_research::IntVar * > const &)*arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonOverlappingBoxesConstraint__SWIG_1___(void * jarg1, void * jarg2, void * jarg3,  int length4, int64_t*  jarg4,  int length5, int64_t*  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< int64_t > *arg4 = 0 ;
  std::vector< int64_t > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = new std::vector<int64_t>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  
  arg5 = new std::vector<int64_t>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeNonOverlappingBoxesConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< int64_t > const &)*arg4,(std::vector< int64_t > const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg4; 
  }
  {
    delete arg5; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonOverlappingBoxesConstraint__SWIG_2___(void * jarg1, void * jarg2, void * jarg3,  int length4, int*  jarg4,  int length5, int*  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  std::vector< int > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  
  arg5 = new std::vector<int>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeNonOverlappingBoxesConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< int > const &)*arg4,(std::vector< int > const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg4; 
  }
  {
    delete arg5; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonOverlappingNonStrictBoxesConstraint__SWIG_0___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  std::vector< operations_research::IntVar * > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg5 = (std::vector< operations_research::IntVar * > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)(arg1)->MakeNonOverlappingNonStrictBoxesConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< operations_research::IntVar * > const &)*arg4,(std::vector< operations_research::IntVar * > const &)*arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonOverlappingNonStrictBoxesConstraint__SWIG_1___(void * jarg1, void * jarg2, void * jarg3,  int length4, int64_t*  jarg4,  int length5, int64_t*  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< int64_t > *arg4 = 0 ;
  std::vector< int64_t > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = new std::vector<int64_t>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  
  arg5 = new std::vector<int64_t>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeNonOverlappingNonStrictBoxesConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< int64_t > const &)*arg4,(std::vector< int64_t > const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg4; 
  }
  {
    delete arg5; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNonOverlappingNonStrictBoxesConstraint__SWIG_2___(void * jarg1, void * jarg2, void * jarg3,  int length4, int*  jarg4,  int length5, int*  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  std::vector< int > *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  
  arg5 = new std::vector<int>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  result = (operations_research::Constraint *)(arg1)->MakeNonOverlappingNonStrictBoxesConstraint((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< int > const &)*arg4,(std::vector< int > const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg4; 
  }
  {
    delete arg5; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePack___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int arg3 ;
  operations_research::Pack *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int)jarg3; 
  result = (operations_research::Pack *)(arg1)->MakePack((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFixedDurationIntervalVar__SWIG_0___(void * jarg1, long long jarg2, long long jarg3, long long jarg4, unsigned int jarg5, char * jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  bool arg5 ;
  std::string *arg6 = 0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = jarg5 ? true : false; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  result = (operations_research::IntervalVar *)(arg1)->MakeFixedDurationIntervalVar(arg2,arg3,arg4,arg5,(std::string const &)*arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFixedDurationIntervalVar__SWIG_1___(void * jarg1, void * jarg2, long long jarg3, char * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  std::string *arg4 = 0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  result = (operations_research::IntervalVar *)(arg1)->MakeFixedDurationIntervalVar(arg2,arg3,(std::string const &)*arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFixedDurationIntervalVar__SWIG_2___(void * jarg1, void * jarg2, long long jarg3, void * jarg4, char * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::string *arg5 = 0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (operations_research::IntervalVar *)(arg1)->MakeFixedDurationIntervalVar(arg2,arg3,arg4,(std::string const &)*arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFixedInterval___(void * jarg1, long long jarg2, long long jarg3, char * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  std::string *arg4 = 0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  result = (operations_research::IntervalVar *)(arg1)->MakeFixedInterval(arg2,arg3,(std::string const &)*arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntervalVar___(void * jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5, long long jarg6, long long jarg7, unsigned int jarg8, char * jarg9) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  int64_t arg6 ;
  int64_t arg7 ;
  bool arg8 ;
  std::string *arg9 = 0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = (int64_t)jarg6; 
  arg7 = (int64_t)jarg7; 
  arg8 = jarg8 ? true : false; 
  if (!jarg9) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg9_str(jarg9);
  arg9 = &arg9_str; 
  result = (operations_research::IntervalVar *)(arg1)->MakeIntervalVar(arg2,arg3,arg4,arg5,arg6,arg7,arg8,(std::string const &)*arg9);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntervalVarArray___(void * jarg1, int jarg2, long long jarg3, long long jarg4, long long jarg5, long long jarg6, long long jarg7, long long jarg8, unsigned int jarg9, char * jarg10, void * jarg11) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  int64_t arg6 ;
  int64_t arg7 ;
  int64_t arg8 ;
  bool arg9 ;
  std::string *arg10 = 0 ;
  std::vector< operations_research::IntervalVar * > *arg11 = (std::vector< operations_research::IntervalVar * > *) (std::vector< operations_research::IntervalVar * > *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = (int64_t)jarg6; 
  arg7 = (int64_t)jarg7; 
  arg8 = (int64_t)jarg8; 
  arg9 = jarg9 ? true : false; 
  if (!jarg10) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg10_str(jarg10);
  arg10 = &arg10_str; 
  arg11 = (std::vector< operations_research::IntervalVar * > *)jarg11; 
  (arg1)->MakeIntervalVarArray(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(std::string const &)*arg10,arg11);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMirrorInterval___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVar *)(arg1)->MakeMirrorInterval(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFixedDurationStartSyncedOnStartIntervalVar___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::IntervalVar *)(arg1)->MakeFixedDurationStartSyncedOnStartIntervalVar(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFixedDurationStartSyncedOnEndIntervalVar___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::IntervalVar *)(arg1)->MakeFixedDurationStartSyncedOnEndIntervalVar(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFixedDurationEndSyncedOnStartIntervalVar___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::IntervalVar *)(arg1)->MakeFixedDurationEndSyncedOnStartIntervalVar(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFixedDurationEndSyncedOnEndIntervalVar___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::IntervalVar *)(arg1)->MakeFixedDurationEndSyncedOnEndIntervalVar(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntervalRelaxedMin___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVar *)(arg1)->MakeIntervalRelaxedMin(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntervalRelaxedMax___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVar *)(arg1)->MakeIntervalRelaxedMax(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntervalVarRelation__SWIG_0___(void * jarg1, void * jarg2, int jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::Solver::UnaryIntervalRelation arg3 ;
  int64_t arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (operations_research::Solver::UnaryIntervalRelation)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIntervalVarRelation(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntervalVarRelation__SWIG_1___(void * jarg1, void * jarg2, int jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::Solver::BinaryIntervalRelation arg3 ;
  operations_research::IntervalVar *arg4 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (operations_research::Solver::BinaryIntervalRelation)jarg3; 
  arg4 = (operations_research::IntervalVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeIntervalVarRelation(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeIntervalVarRelationWithDelay___(void * jarg1, void * jarg2, int jarg3, void * jarg4, long long jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::Solver::BinaryIntervalRelation arg3 ;
  operations_research::IntervalVar *arg4 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg5 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (operations_research::Solver::BinaryIntervalRelation)jarg3; 
  arg4 = (operations_research::IntervalVar *)jarg4; 
  arg5 = (int64_t)jarg5; 
  result = (operations_research::Constraint *)(arg1)->MakeIntervalVarRelationWithDelay(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeTemporalDisjunction__SWIG_0___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  result = (operations_research::Constraint *)(arg1)->MakeTemporalDisjunction(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeTemporalDisjunction__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeTemporalDisjunction(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDisjunctiveConstraint___(void * jarg1, void * jarg2, char * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  operations_research::DisjunctiveConstraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  result = (operations_research::DisjunctiveConstraint *)(arg1)->MakeDisjunctiveConstraint((std::vector< operations_research::IntervalVar * > const &)*arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeStrictDisjunctiveConstraint___(void * jarg1, void * jarg2, char * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::string *arg3 = 0 ;
  operations_research::DisjunctiveConstraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  result = (operations_research::DisjunctiveConstraint *)(arg1)->MakeStrictDisjunctiveConstraint((std::vector< operations_research::IntervalVar * > const &)*arg2,(std::string const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCumulative__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, long long jarg4, char * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  int64_t arg4 ;
  std::string *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (operations_research::Constraint *)(arg1)->MakeCumulative((std::vector< operations_research::IntervalVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4,(std::string const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCumulative__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3, long long jarg4, char * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  int64_t arg4 ;
  std::string *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (operations_research::Constraint *)(arg1)->MakeCumulative((std::vector< operations_research::IntervalVar * > const &)*arg2,(std::vector< int > const &)*arg3,arg4,(std::string const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCumulative__SWIG_2___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, void * jarg4, char * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::string *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (operations_research::IntVar *)jarg4; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (operations_research::Constraint *)(arg1)->MakeCumulative((std::vector< operations_research::IntervalVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4,(std::string const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCumulative__SWIG_3___(void * jarg1, void * jarg2,  int length3, int*  jarg3, void * jarg4, char * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::string *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (operations_research::IntVar *)jarg4; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (operations_research::Constraint *)(arg1)->MakeCumulative((std::vector< operations_research::IntervalVar * > const &)*arg2,(std::vector< int > const &)*arg3,arg4,(std::string const &)*arg5);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCumulative__SWIG_4___(void * jarg1, void * jarg2, void * jarg3, long long jarg4, char * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  int64_t arg4 ;
  std::string *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (int64_t)jarg4; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (operations_research::Constraint *)(arg1)->MakeCumulative((std::vector< operations_research::IntervalVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4,(std::string const &)*arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCumulative__SWIG_5___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, char * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::string *arg5 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (operations_research::IntVar *)jarg4; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (operations_research::Constraint *)(arg1)->MakeCumulative((std::vector< operations_research::IntervalVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4,(std::string const &)*arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCover___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeCover((std::vector< operations_research::IntervalVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeEquality__SWIG_3___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  result = (operations_research::Constraint *)(arg1)->MakeEquality(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAssignment__SWIG_0___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Assignment *)(arg1)->MakeAssignment();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAssignment__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (operations_research::Assignment *)(arg1)->MakeAssignment((operations_research::Assignment const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFirstSolutionCollector__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeFirstSolutionCollector((operations_research::Assignment const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFirstSolutionCollector__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeFirstSolutionCollector();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLastSolutionCollector__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeLastSolutionCollector((operations_research::Assignment const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLastSolutionCollector__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeLastSolutionCollector();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeBestValueSolutionCollector__SWIG_0___(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool arg3 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeBestValueSolutionCollector((operations_research::Assignment const *)arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeBestValueSolutionCollector__SWIG_1___(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeBestValueSolutionCollector(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNBestValueSolutionCollector__SWIG_0___(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  int arg3 ;
  bool arg4 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = jarg4 ? true : false; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeNBestValueSolutionCollector((operations_research::Assignment const *)arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNBestValueSolutionCollector__SWIG_1___(void * jarg1, int jarg2, unsigned int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  bool arg3 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeNBestValueSolutionCollector(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAllSolutionCollector__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeAllSolutionCollector((operations_research::Assignment const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAllSolutionCollector__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::SolutionCollector *)(arg1)->MakeAllSolutionCollector();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMinimize___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeMinimize(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMaximize___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeMaximize(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeOptimize___(void * jarg1, unsigned int jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeOptimize(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeWeightedMinimize__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeWeightedMinimize((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeWeightedMinimize__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeWeightedMinimize((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeWeightedMaximize__SWIG_0___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeWeightedMaximize((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeWeightedMaximize__SWIG_1___(void * jarg1, void * jarg2,  int length3, int*  jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (int64_t)jarg4; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeWeightedMaximize((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeWeightedOptimize__SWIG_0___(void * jarg1, unsigned int jarg2, void * jarg3,  int length4, int64_t*  jarg4, long long jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< int64_t > *arg4 = 0 ;
  int64_t arg5 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = new std::vector<int64_t>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  arg5 = (int64_t)jarg5; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeWeightedOptimize(arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< int64_t > const &)*arg4,arg5);
  jresult = (void *)result; 
  {
    delete arg4; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeWeightedOptimize__SWIG_1___(void * jarg1, unsigned int jarg2, void * jarg3,  int length4, int*  jarg4, long long jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  int64_t arg5 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  arg5 = (int64_t)jarg5; 
  result = (operations_research::OptimizeVar *)(arg1)->MakeWeightedOptimize(arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< int > const &)*arg4,arg5);
  jresult = (void *)result; 
  {
    delete arg4; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeTabuSearch___(void * jarg1, unsigned int jarg2, void * jarg3, long long jarg4, void * jarg5, long long jarg6, long long jarg7, double jarg8) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  std::vector< operations_research::IntVar * > *arg5 = 0 ;
  int64_t arg6 ;
  int64_t arg7 ;
  double arg8 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (std::vector< operations_research::IntVar * > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg6 = (int64_t)jarg6; 
  arg7 = (int64_t)jarg7; 
  arg8 = (double)jarg8; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeTabuSearch(arg2,arg3,arg4,(std::vector< operations_research::IntVar * > const &)*arg5,arg6,arg7,arg8);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGenericTabuSearch___(void * jarg1, unsigned int jarg2, void * jarg3, long long jarg4, void * jarg5, long long jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  std::vector< operations_research::IntVar * > *arg5 = 0 ;
  int64_t arg6 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (std::vector< operations_research::IntVar * > *)jarg5;
  if (!arg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg6 = (int64_t)jarg6; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeGenericTabuSearch(arg2,arg3,arg4,(std::vector< operations_research::IntVar * > const &)*arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSimulatedAnnealing___(void * jarg1, unsigned int jarg2, void * jarg3, long long jarg4, long long jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  int64_t arg5 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSimulatedAnnealing(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGuidedLocalSearch__SWIG_0___(void * jarg1, unsigned int jarg2, void * jarg3,  void *  jarg4, long long jarg5, void * jarg6, double jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Solver::IndexEvaluator2 arg4 ;
  int64_t arg5 ;
  std::vector< operations_research::IntVar * > *arg6 = 0 ;
  double arg7 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (operations_research::IntVar *)jarg3; 
  
  arg4 = [jarg4](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg4)(t, u);
  };
  
  arg5 = (int64_t)jarg5; 
  arg6 = (std::vector< operations_research::IntVar * > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg7 = (double)jarg7; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeGuidedLocalSearch(arg2,arg3,arg4,arg5,(std::vector< operations_research::IntVar * > const &)*arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeGuidedLocalSearch__SWIG_1___(void * jarg1, unsigned int jarg2, void * jarg3,  void *  jarg4, long long jarg5, void * jarg6, void * jarg7, double jarg8) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Solver::IndexEvaluator3 arg4 ;
  int64_t arg5 ;
  std::vector< operations_research::IntVar * > *arg6 = 0 ;
  std::vector< operations_research::IntVar * > *arg7 = 0 ;
  double arg8 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (operations_research::IntVar *)jarg3; 
  
  arg4 = [jarg4](int64_t t, int64_t u, int64_t v) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t, int64_t))jarg4)(t, u, v);
  };
  
  arg5 = (int64_t)jarg5; 
  arg6 = (std::vector< operations_research::IntVar * > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg7 = (std::vector< operations_research::IntVar * > *)jarg7;
  if (!arg7) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg8 = (double)jarg8; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeGuidedLocalSearch(arg2,arg3,arg4,arg5,(std::vector< operations_research::IntVar * > const &)*arg6,(std::vector< operations_research::IntVar * > const &)*arg7,arg8);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLubyRestart___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeLubyRestart(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeConstantRestart___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeConstantRestart(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeTimeLimit__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  absl::Duration arg2 ;
  absl::Duration *argp2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  argp2 = (absl::Duration *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null absl::Duration", 0);
    return 0;
  }
  arg2 = *argp2; 
  result = (operations_research::RegularLimit *)(arg1)->MakeTimeLimit(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeTimeLimit__SWIG_1___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::RegularLimit *)(arg1)->MakeTimeLimit(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeBranchesLimit___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::RegularLimit *)(arg1)->MakeBranchesLimit(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFailuresLimit___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::RegularLimit *)(arg1)->MakeFailuresLimit(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSolutionsLimit___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::RegularLimit *)(arg1)->MakeSolutionsLimit(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLimit__SWIG_0___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, long long jarg5, unsigned int jarg6, unsigned int jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  absl::Duration arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  bool arg6 ;
  bool arg7 ;
  absl::Duration *argp2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  argp2 = (absl::Duration *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null absl::Duration", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = jarg7 ? true : false; 
  result = (operations_research::RegularLimit *)(arg1)->MakeLimit(arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLimit__SWIG_1___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, long long jarg5, unsigned int jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  absl::Duration arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  bool arg6 ;
  absl::Duration *argp2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  argp2 = (absl::Duration *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null absl::Duration", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = jarg6 ? true : false; 
  result = (operations_research::RegularLimit *)(arg1)->MakeLimit(arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLimit__SWIG_2___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, long long jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  absl::Duration arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  absl::Duration *argp2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  argp2 = (absl::Duration *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null absl::Duration", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  result = (operations_research::RegularLimit *)(arg1)->MakeLimit(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLimit__SWIG_3___(void * jarg1, int proto_size, uint8_t* jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::RegularLimitParameters *arg2 = 0 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  {
    arg2 = new operations_research::RegularLimitParameters;
    bool parsed_ok = arg2->ParseFromArray(jarg2, proto_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RegularLimitParameters protocol message.");
    }
  }
  result = (operations_research::RegularLimit *)(arg1)->MakeLimit((operations_research::RegularLimitParameters const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2;
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLimit__SWIG_4___(void * jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5, unsigned int jarg6, unsigned int jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  bool arg6 ;
  bool arg7 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = jarg7 ? true : false; 
  result = (operations_research::RegularLimit *)(arg1)->MakeLimit(arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLimit__SWIG_5___(void * jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5, unsigned int jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  bool arg6 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = jarg6 ? true : false; 
  result = (operations_research::RegularLimit *)(arg1)->MakeLimit(arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLimit__SWIG_6___(void * jarg1, long long jarg2, long long jarg3, long long jarg4, long long jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  result = (operations_research::RegularLimit *)(arg1)->MakeLimit(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT uint8_t* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDefaultRegularLimitParameters___(void * jarg1) {
  uint8_t* jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::RegularLimitParameters result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = ((operations_research::Solver const *)arg1)->MakeDefaultRegularLimitParameters();
  {
    const long size = (&result)->ByteSizeLong();
    jresult = new uint8_t[size + 4];
    (&result)->SerializeWithCachedSizesToArray(jresult + 4);
    jresult[0] = size & 0xFF;
    jresult[1] = (size >> 8) & 0xFF;
    jresult[2] = (size >> 16) & 0xFF;
    jresult[3] = (size >> 24) & 0xFF;
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLimit__SWIG_7___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SearchLimit *arg2 = (operations_research::SearchLimit *) (operations_research::SearchLimit *)0 ;
  operations_research::SearchLimit *arg3 = (operations_research::SearchLimit *) (operations_research::SearchLimit *)0 ;
  operations_research::SearchLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::SearchLimit *)jarg2; 
  arg3 = (operations_research::SearchLimit *)jarg3; 
  result = (operations_research::SearchLimit *)(arg1)->MakeLimit(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeImprovementLimit___(void * jarg1, void * jarg2, unsigned int jarg3, double jarg4, double jarg5, double jarg6, int jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  bool arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  operations_research::ImprovementSearchLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (double)jarg4; 
  arg5 = (double)jarg5; 
  arg6 = (double)jarg6; 
  arg7 = (int)jarg7; 
  result = (operations_research::ImprovementSearchLimit *)(arg1)->MakeImprovementLimit(arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeCustomLimit___(void * jarg1,  void *  jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::function< bool () > arg2 ;
  operations_research::SearchLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2]() -> bool {
    return (*(bool(*)())jarg2)();
  };
  
  result = (operations_research::SearchLimit *)(arg1)->MakeCustomLimit(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSearchLog__SWIG_0___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSearchLog(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSearchLog__SWIG_1___(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSearchLog(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSearchLog__SWIG_2___(void * jarg1, int jarg2,  void *  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  SwigValueWrapper< std::function< std::string () > > arg3 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  
  arg3 = [jarg3]() -> std::string {
    std::string result;
    return result.assign((*(char* (*)()) jarg3)());
  };
  
  result = (operations_research::SearchMonitor *)(arg1)->MakeSearchLog(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSearchLog__SWIG_3___(void * jarg1, int jarg2, void * jarg3,  void *  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) 0 ;
  SwigValueWrapper< std::function< std::string () > > arg4 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  
  arg4 = [jarg4]() -> std::string {
    std::string result;
    return result.assign((*(char* (*)()) jarg4)());
  };
  
  result = (operations_research::SearchMonitor *)(arg1)->MakeSearchLog(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSearchLog__SWIG_4___(void * jarg1, int jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  operations_research::OptimizeVar *arg3 = (operations_research::OptimizeVar *) (operations_research::OptimizeVar *)0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::OptimizeVar *)jarg3; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSearchLog(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSearchLog__SWIG_5___(void * jarg1, int jarg2, void * jarg3,  void *  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int arg2 ;
  operations_research::OptimizeVar *arg3 = (operations_research::OptimizeVar *) (operations_research::OptimizeVar *)0 ;
  SwigValueWrapper< std::function< std::string () > > arg4 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::OptimizeVar *)jarg3; 
  
  arg4 = [jarg4]() -> std::string {
    std::string result;
    return result.assign((*(char* (*)()) jarg4)());
  };
  
  result = (operations_research::SearchMonitor *)(arg1)->MakeSearchLog(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSearchTrace___(void * jarg1, char * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSearchTrace((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeEnterSearchCallback___(void * jarg1,  void *  jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::function< void () > arg2 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  result = (operations_research::SearchMonitor *)(arg1)->MakeEnterSearchCallback(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeExitSearchCallback___(void * jarg1,  void *  jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::function< void () > arg2 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  result = (operations_research::SearchMonitor *)(arg1)->MakeExitSearchCallback(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAtSolutionCallback___(void * jarg1,  void *  jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::function< void () > arg2 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  result = (operations_research::SearchMonitor *)(arg1)->MakeAtSolutionCallback(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePrintModelVisitor___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::ModelVisitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::ModelVisitor *)(arg1)->MakePrintModelVisitor();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeStatisticsModelVisitor___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::ModelVisitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::ModelVisitor *)(arg1)->MakeStatisticsModelVisitor();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSymmetryManager__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::SymmetryBreaker * > *arg2 = 0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::SymmetryBreaker * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SymmetryBreaker * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSymmetryManager((std::vector< operations_research::SymmetryBreaker * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSymmetryManager__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SymmetryBreaker *arg2 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::SymmetryBreaker *)jarg2; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSymmetryManager(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSymmetryManager__SWIG_2___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SymmetryBreaker *arg2 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SymmetryBreaker *arg3 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::SymmetryBreaker *)jarg2; 
  arg3 = (operations_research::SymmetryBreaker *)jarg3; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSymmetryManager(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSymmetryManager__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SymmetryBreaker *arg2 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SymmetryBreaker *arg3 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SymmetryBreaker *arg4 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::SymmetryBreaker *)jarg2; 
  arg3 = (operations_research::SymmetryBreaker *)jarg3; 
  arg4 = (operations_research::SymmetryBreaker *)jarg4; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSymmetryManager(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSymmetryManager__SWIG_4___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SymmetryBreaker *arg2 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SymmetryBreaker *arg3 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SymmetryBreaker *arg4 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SymmetryBreaker *arg5 = (operations_research::SymmetryBreaker *) (operations_research::SymmetryBreaker *)0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::SymmetryBreaker *)jarg2; 
  arg3 = (operations_research::SymmetryBreaker *)jarg3; 
  arg4 = (operations_research::SymmetryBreaker *)jarg4; 
  arg5 = (operations_research::SymmetryBreaker *)jarg5; 
  result = (operations_research::SearchMonitor *)(arg1)->MakeSymmetryManager(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAssignVariableValue___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Decision *)(arg1)->MakeAssignVariableValue(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeVariableLessOrEqualValue___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Decision *)(arg1)->MakeVariableLessOrEqualValue(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeVariableGreaterOrEqualValue___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Decision *)(arg1)->MakeVariableGreaterOrEqualValue(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSplitVariableDomain___(void * jarg1, void * jarg2, long long jarg3, unsigned int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  bool arg4 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = jarg4 ? true : false; 
  result = (operations_research::Decision *)(arg1)->MakeSplitVariableDomain(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAssignVariableValueOrFail___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Decision *)(arg1)->MakeAssignVariableValueOrFail(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAssignVariableValueOrDoNothing___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Decision *)(arg1)->MakeAssignVariableValueOrDoNothing(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAssignVariablesValues___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::Decision *)(arg1)->MakeAssignVariablesValues((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeFailDecision___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Decision *)(arg1)->MakeFailDecision();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDecision___(void * jarg1,  void *  jarg2,  void *  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  SwigValueWrapper< std::function< void (operations_research::Solver *) > > arg2 ;
  SwigValueWrapper< std::function< void (operations_research::Solver *) > > arg3 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  
  arg2 = [jarg2](operations_research::Solver* s) -> void {
    return (*(void(*)(operations_research::Solver*))jarg2)(s);
  };
  
  
  arg3 = [jarg3](operations_research::Solver* s) -> void {
    return (*(void(*)(operations_research::Solver*))jarg3)(s);
  };
  
  result = (operations_research::Decision *)(arg1)->MakeDecision(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Compose__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  result = (operations_research::DecisionBuilder *)(arg1)->Compose(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Compose__SWIG_1___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg4 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  arg4 = (operations_research::DecisionBuilder *)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->Compose(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Compose__SWIG_2___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg4 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg5 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  arg4 = (operations_research::DecisionBuilder *)jarg4; 
  arg5 = (operations_research::DecisionBuilder *)jarg5; 
  result = (operations_research::DecisionBuilder *)(arg1)->Compose(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Compose__SWIG_3___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::DecisionBuilder * > *arg2 = 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::DecisionBuilder * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::DecisionBuilder * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::DecisionBuilder *)(arg1)->Compose((std::vector< operations_research::DecisionBuilder * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Try__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  result = (operations_research::DecisionBuilder *)(arg1)->Try(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Try__SWIG_1___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg4 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  arg4 = (operations_research::DecisionBuilder *)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->Try(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Try__SWIG_2___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg4 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg5 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  arg4 = (operations_research::DecisionBuilder *)jarg4; 
  arg5 = (operations_research::DecisionBuilder *)jarg5; 
  result = (operations_research::DecisionBuilder *)(arg1)->Try(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Try__SWIG_3___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::DecisionBuilder * > *arg2 = 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::DecisionBuilder * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::DecisionBuilder * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::DecisionBuilder *)(arg1)->Try((std::vector< operations_research::DecisionBuilder * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_0___(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IntVarStrategy arg3 ;
  operations_research::Solver::IntValueStrategy arg4 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::Solver::IntVarStrategy)jarg3; 
  arg4 = (operations_research::Solver::IntValueStrategy)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_1___(void * jarg1, void * jarg2,  void *  jarg3, int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IndexEvaluator1 arg3 ;
  operations_research::Solver::IntValueStrategy arg4 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = [jarg3](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg3)(t);
  };
  
  arg4 = (operations_research::Solver::IntValueStrategy)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_2___(void * jarg1, void * jarg2, int jarg3,  void *  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IntVarStrategy arg3 ;
  operations_research::Solver::IndexEvaluator2 arg4 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::Solver::IntVarStrategy)jarg3; 
  
  arg4 = [jarg4](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg4)(t, u);
  };
  
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_3___(void * jarg1, void * jarg2, int jarg3,  void *  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IntVarStrategy arg3 ;
  operations_research::Solver::VariableValueComparator arg4 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::Solver::IntVarStrategy)jarg3; 
  
  arg4 = [jarg4](int64_t t, int64_t u, int64_t v) -> bool {
    return (*(bool(*)(int64_t, int64_t, int64_t))jarg4)(t, u, v);
  };
  
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_4___(void * jarg1, void * jarg2,  void *  jarg3,  void *  jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IndexEvaluator1 arg3 ;
  operations_research::Solver::IndexEvaluator2 arg4 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = [jarg3](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg3)(t);
  };
  
  
  arg4 = [jarg4](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg4)(t, u);
  };
  
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_5___(void * jarg1, void * jarg2, int jarg3,  void *  jarg4,  void *  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IntVarStrategy arg3 ;
  operations_research::Solver::IndexEvaluator2 arg4 ;
  operations_research::Solver::IndexEvaluator1 arg5 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::Solver::IntVarStrategy)jarg3; 
  
  arg4 = [jarg4](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg4)(t, u);
  };
  
  
  arg5 = [jarg5](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg5)(t);
  };
  
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_6___(void * jarg1, void * jarg2,  void *  jarg3,  void *  jarg4,  void *  jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IndexEvaluator1 arg3 ;
  operations_research::Solver::IndexEvaluator2 arg4 ;
  operations_research::Solver::IndexEvaluator1 arg5 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = [jarg3](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg3)(t);
  };
  
  
  arg4 = [jarg4](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg4)(t, u);
  };
  
  
  arg5 = [jarg5](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg5)(t);
  };
  
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDefaultPhase__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeDefaultPhase((std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDefaultPhase__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::DefaultPhaseParameters *arg3 = 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::DefaultPhaseParameters *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::DefaultPhaseParameters const & type is null", 0);
    return 0;
  } 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeDefaultPhase((std::vector< operations_research::IntVar * > const &)*arg2,(operations_research::DefaultPhaseParameters const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_7___(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Solver::IntVarStrategy arg3 ;
  operations_research::Solver::IntValueStrategy arg4 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::Solver::IntVarStrategy)jarg3; 
  arg4 = (operations_research::Solver::IntValueStrategy)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_8___(void * jarg1, void * jarg2, void * jarg3, int jarg4, int jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Solver::IntVarStrategy arg4 ;
  operations_research::Solver::IntValueStrategy arg5 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (operations_research::Solver::IntVarStrategy)jarg4; 
  arg5 = (operations_research::Solver::IntValueStrategy)jarg5; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_9___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5, int jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Solver::IntVarStrategy arg5 ;
  operations_research::Solver::IntValueStrategy arg6 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  arg5 = (operations_research::Solver::IntVarStrategy)jarg5; 
  arg6 = (operations_research::Solver::IntValueStrategy)jarg6; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase(arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_10___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6, int jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg4 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *arg5 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::Solver::IntVarStrategy arg6 ;
  operations_research::Solver::IntValueStrategy arg7 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (operations_research::IntVar *)jarg4; 
  arg5 = (operations_research::IntVar *)jarg5; 
  arg6 = (operations_research::Solver::IntVarStrategy)jarg6; 
  arg7 = (operations_research::Solver::IntValueStrategy)jarg7; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase(arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScheduleOrPostpone___(void * jarg1, void * jarg2, long long jarg3, long * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t *arg4 = (int64_t *) (int64_t *)0 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t *)jarg4; 
  result = (operations_research::Decision *)(arg1)->MakeScheduleOrPostpone(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeScheduleOrExpedite___(void * jarg1, void * jarg2, long long jarg3, long * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t *arg4 = (int64_t *) (int64_t *)0 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t *)jarg4; 
  result = (operations_research::Decision *)(arg1)->MakeScheduleOrExpedite(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeRankFirstInterval___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  int arg3 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::Decision *)(arg1)->MakeRankFirstInterval(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeRankLastInterval___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  int arg3 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::Decision *)(arg1)->MakeRankLastInterval(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_11___(void * jarg1, void * jarg2,  void *  jarg3, int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IndexEvaluator2 arg3 ;
  operations_research::Solver::EvaluatorStrategy arg4 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = [jarg3](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg3)(t, u);
  };
  
  arg4 = (operations_research::Solver::EvaluatorStrategy)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_12___(void * jarg1, void * jarg2,  void *  jarg3,  void *  jarg4, int jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IndexEvaluator2 arg3 ;
  operations_research::Solver::IndexEvaluator1 arg4 ;
  operations_research::Solver::EvaluatorStrategy arg5 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = [jarg3](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg3)(t, u);
  };
  
  
  arg4 = [jarg4](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg4)(t);
  };
  
  arg5 = (operations_research::Solver::EvaluatorStrategy)jarg5; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_13___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  operations_research::Solver::IntervalStrategy arg3 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::Solver::IntervalStrategy)jarg3; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::IntervalVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakePhase__SWIG_14___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::SequenceVar * > *arg2 = 0 ;
  operations_research::Solver::SequenceStrategy arg3 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::SequenceVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::Solver::SequenceStrategy)jarg3; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakePhase((std::vector< operations_research::SequenceVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDecisionBuilderFromAssignment___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeDecisionBuilderFromAssignment(arg2,arg3,(std::vector< operations_research::IntVar * > const &)*arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeConstraintAdder___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeConstraintAdder(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSolveOnce__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeSolveOnce(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSolveOnce__SWIG_1___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeSolveOnce(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSolveOnce__SWIG_2___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeSolveOnce(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSolveOnce__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg5 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  arg5 = (operations_research::SearchMonitor *)jarg5; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeSolveOnce(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSolveOnce__SWIG_4___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::SearchMonitor *arg3 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg4 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg5 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg6 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::SearchMonitor *)jarg3; 
  arg4 = (operations_research::SearchMonitor *)jarg4; 
  arg5 = (operations_research::SearchMonitor *)jarg5; 
  arg6 = (operations_research::SearchMonitor *)jarg6; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeSolveOnce(arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSolveOnce__SWIG_5___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  std::vector< operations_research::SearchMonitor * > *arg3 = 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (std::vector< operations_research::SearchMonitor * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeSolveOnce(arg2,(std::vector< operations_research::SearchMonitor * > const &)*arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNestedOptimize__SWIG_0___(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, long long jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool arg4 ;
  int64_t arg5 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (int64_t)jarg5; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeNestedOptimize(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNestedOptimize__SWIG_1___(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, long long jarg5, void * jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool arg4 ;
  int64_t arg5 ;
  operations_research::SearchMonitor *arg6 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (int64_t)jarg5; 
  arg6 = (operations_research::SearchMonitor *)jarg6; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeNestedOptimize(arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNestedOptimize__SWIG_2___(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, long long jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool arg4 ;
  int64_t arg5 ;
  operations_research::SearchMonitor *arg6 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg7 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (int64_t)jarg5; 
  arg6 = (operations_research::SearchMonitor *)jarg6; 
  arg7 = (operations_research::SearchMonitor *)jarg7; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeNestedOptimize(arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNestedOptimize__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, long long jarg5, void * jarg6, void * jarg7, void * jarg8) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool arg4 ;
  int64_t arg5 ;
  operations_research::SearchMonitor *arg6 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg7 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg8 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (int64_t)jarg5; 
  arg6 = (operations_research::SearchMonitor *)jarg6; 
  arg7 = (operations_research::SearchMonitor *)jarg7; 
  arg8 = (operations_research::SearchMonitor *)jarg8; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeNestedOptimize(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNestedOptimize__SWIG_4___(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, long long jarg5, void * jarg6, void * jarg7, void * jarg8, void * jarg9) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool arg4 ;
  int64_t arg5 ;
  operations_research::SearchMonitor *arg6 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg7 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg8 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::SearchMonitor *arg9 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (int64_t)jarg5; 
  arg6 = (operations_research::SearchMonitor *)jarg6; 
  arg7 = (operations_research::SearchMonitor *)jarg7; 
  arg8 = (operations_research::SearchMonitor *)jarg8; 
  arg9 = (operations_research::SearchMonitor *)jarg9; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeNestedOptimize(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNestedOptimize__SWIG_5___(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4, long long jarg5, void * jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool arg4 ;
  int64_t arg5 ;
  std::vector< operations_research::SearchMonitor * > *arg6 = 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = jarg4 ? true : false; 
  arg5 = (int64_t)jarg5; 
  arg6 = (std::vector< operations_research::SearchMonitor * > *)jarg6;
  if (!arg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SearchMonitor * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeNestedOptimize(arg2,arg3,arg4,arg5,(std::vector< operations_research::SearchMonitor * > const &)*arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeRestoreAssignment___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeRestoreAssignment(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeStoreAssignment___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeStoreAssignment(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeOperator__SWIG_0___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::LocalSearchOperators arg3 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::Solver::LocalSearchOperators)jarg3; 
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeOperator((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeOperator__SWIG_1___(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Solver::LocalSearchOperators arg4 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg4 = (operations_research::Solver::LocalSearchOperators)jarg4; 
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeOperator((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeOperator__SWIG_2___(void * jarg1, void * jarg2,  void *  jarg3, int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IndexEvaluator3 arg3 ;
  operations_research::Solver::EvaluatorLocalSearchOperators arg4 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = [jarg3](int64_t t, int64_t u, int64_t v) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t, int64_t))jarg3)(t, u, v);
  };
  
  arg4 = (operations_research::Solver::EvaluatorLocalSearchOperators)jarg4; 
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeOperator((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeOperator__SWIG_3___(void * jarg1, void * jarg2, void * jarg3,  void *  jarg4, int jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Solver::IndexEvaluator3 arg4 ;
  operations_research::Solver::EvaluatorLocalSearchOperators arg5 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = [jarg4](int64_t t, int64_t u, int64_t v) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t, int64_t))jarg4)(t, u, v);
  };
  
  arg5 = (operations_research::Solver::EvaluatorLocalSearchOperators)jarg5; 
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeOperator((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeRandomLnsOperator__SWIG_0___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int arg3 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int)jarg3; 
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeRandomLnsOperator((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeRandomLnsOperator__SWIG_1___(void * jarg1, void * jarg2, int jarg3, int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int arg3 ;
  int32_t arg4 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int)jarg3; 
  arg4 = (int32_t)jarg4; 
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeRandomLnsOperator((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMoveTowardTargetOperator__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = 0 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::Assignment const & type is null", 0);
    return 0;
  } 
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeMoveTowardTargetOperator((operations_research::Assignment const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeMoveTowardTargetOperator__SWIG_1___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeMoveTowardTargetOperator((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ConcatenateOperators__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::LocalSearchOperator * > *arg2 = 0 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchOperator * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::LocalSearchOperator *)(arg1)->ConcatenateOperators((std::vector< operations_research::LocalSearchOperator * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ConcatenateOperators__SWIG_1___(void * jarg1, void * jarg2, unsigned int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::LocalSearchOperator * > *arg2 = 0 ;
  bool arg3 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchOperator * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return 0;
  } 
  arg3 = jarg3 ? true : false; 
  result = (operations_research::LocalSearchOperator *)(arg1)->ConcatenateOperators((std::vector< operations_research::LocalSearchOperator * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ConcatenateOperators__SWIG_2___(void * jarg1, void * jarg2,  void *  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::LocalSearchOperator * > *arg2 = 0 ;
  std::function< int64_t (int,int) > arg3 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchOperator * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = [jarg3](int t, int u) -> int64_t {
    return (*(int64_t(*)(int, int))jarg3)(t, u);
  };
  
  result = (operations_research::LocalSearchOperator *)(arg1)->ConcatenateOperators((std::vector< operations_research::LocalSearchOperator * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RandomConcatenateOperators__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::LocalSearchOperator * > *arg2 = 0 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchOperator * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::LocalSearchOperator *)(arg1)->RandomConcatenateOperators((std::vector< operations_research::LocalSearchOperator * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RandomConcatenateOperators__SWIG_1___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::LocalSearchOperator * > *arg2 = 0 ;
  int32_t arg3 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchOperator * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int32_t)jarg3; 
  result = (operations_research::LocalSearchOperator *)(arg1)->RandomConcatenateOperators((std::vector< operations_research::LocalSearchOperator * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MultiArmedBanditConcatenateOperators___(void * jarg1, void * jarg2, double jarg3, double jarg4, unsigned int jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::LocalSearchOperator * > *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  bool arg5 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::LocalSearchOperator * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::LocalSearchOperator * > const & type is null", 0);
    return 0;
  } 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  arg5 = jarg5 ? true : false; 
  result = (operations_research::LocalSearchOperator *)(arg1)->MultiArmedBanditConcatenateOperators((std::vector< operations_research::LocalSearchOperator * > const &)*arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeNeighborhoodLimit___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::LocalSearchOperator *arg2 = (operations_research::LocalSearchOperator *) (operations_research::LocalSearchOperator *)0 ;
  int64_t arg3 ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::LocalSearchOperator *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::LocalSearchOperator *)(arg1)->MakeNeighborhoodLimit(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhase__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  operations_research::LocalSearchPhaseParameters *arg3 = (operations_research::LocalSearchPhaseParameters *) (operations_research::LocalSearchPhaseParameters *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::LocalSearchPhaseParameters *)jarg3; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeLocalSearchPhase(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhase__SWIG_1___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::LocalSearchPhaseParameters *arg4 = (operations_research::LocalSearchPhaseParameters *) (operations_research::LocalSearchPhaseParameters *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  arg4 = (operations_research::LocalSearchPhaseParameters *)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeLocalSearchPhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhase__SWIG_2___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::DecisionBuilder *arg4 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::LocalSearchPhaseParameters *arg5 = (operations_research::LocalSearchPhaseParameters *) (operations_research::LocalSearchPhaseParameters *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  arg4 = (operations_research::DecisionBuilder *)jarg4; 
  arg5 = (operations_research::LocalSearchPhaseParameters *)jarg5; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeLocalSearchPhase((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhase__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::SequenceVar * > *arg2 = 0 ;
  operations_research::DecisionBuilder *arg3 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::LocalSearchPhaseParameters *arg4 = (operations_research::LocalSearchPhaseParameters *) (operations_research::LocalSearchPhaseParameters *)0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::SequenceVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::DecisionBuilder *)jarg3; 
  arg4 = (operations_research::LocalSearchPhaseParameters *)jarg4; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeLocalSearchPhase((std::vector< operations_research::SequenceVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeDefaultSolutionPool___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::SolutionPool *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::SolutionPool *)(arg1)->MakeDefaultSolutionPool();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhaseParameters__SWIG_0___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  operations_research::LocalSearchOperator *arg3 = (operations_research::LocalSearchOperator *) (operations_research::LocalSearchOperator *)0 ;
  operations_research::DecisionBuilder *arg4 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::LocalSearchPhaseParameters *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::LocalSearchOperator *)jarg3; 
  arg4 = (operations_research::DecisionBuilder *)jarg4; 
  result = (operations_research::LocalSearchPhaseParameters *)(arg1)->MakeLocalSearchPhaseParameters(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhaseParameters__SWIG_1___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  operations_research::LocalSearchOperator *arg3 = (operations_research::LocalSearchOperator *) (operations_research::LocalSearchOperator *)0 ;
  operations_research::DecisionBuilder *arg4 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::RegularLimit *arg5 = (operations_research::RegularLimit *) (operations_research::RegularLimit *)0 ;
  operations_research::LocalSearchPhaseParameters *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::LocalSearchOperator *)jarg3; 
  arg4 = (operations_research::DecisionBuilder *)jarg4; 
  arg5 = (operations_research::RegularLimit *)jarg5; 
  result = (operations_research::LocalSearchPhaseParameters *)(arg1)->MakeLocalSearchPhaseParameters(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhaseParameters__SWIG_2___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  operations_research::LocalSearchOperator *arg3 = (operations_research::LocalSearchOperator *) (operations_research::LocalSearchOperator *)0 ;
  operations_research::DecisionBuilder *arg4 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::RegularLimit *arg5 = (operations_research::RegularLimit *) (operations_research::RegularLimit *)0 ;
  operations_research::LocalSearchFilterManager *arg6 = (operations_research::LocalSearchFilterManager *) 0 ;
  operations_research::LocalSearchPhaseParameters *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::LocalSearchOperator *)jarg3; 
  arg4 = (operations_research::DecisionBuilder *)jarg4; 
  arg5 = (operations_research::RegularLimit *)jarg5; 
  arg6 = (operations_research::LocalSearchFilterManager *)jarg6; 
  result = (operations_research::LocalSearchPhaseParameters *)(arg1)->MakeLocalSearchPhaseParameters(arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhaseParameters__SWIG_3___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  operations_research::SolutionPool *arg3 = (operations_research::SolutionPool *) (operations_research::SolutionPool *)0 ;
  operations_research::LocalSearchOperator *arg4 = (operations_research::LocalSearchOperator *) (operations_research::LocalSearchOperator *)0 ;
  operations_research::DecisionBuilder *arg5 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::LocalSearchPhaseParameters *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::SolutionPool *)jarg3; 
  arg4 = (operations_research::LocalSearchOperator *)jarg4; 
  arg5 = (operations_research::DecisionBuilder *)jarg5; 
  result = (operations_research::LocalSearchPhaseParameters *)(arg1)->MakeLocalSearchPhaseParameters(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhaseParameters__SWIG_4___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  operations_research::SolutionPool *arg3 = (operations_research::SolutionPool *) (operations_research::SolutionPool *)0 ;
  operations_research::LocalSearchOperator *arg4 = (operations_research::LocalSearchOperator *) (operations_research::LocalSearchOperator *)0 ;
  operations_research::DecisionBuilder *arg5 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::RegularLimit *arg6 = (operations_research::RegularLimit *) (operations_research::RegularLimit *)0 ;
  operations_research::LocalSearchPhaseParameters *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::SolutionPool *)jarg3; 
  arg4 = (operations_research::LocalSearchOperator *)jarg4; 
  arg5 = (operations_research::DecisionBuilder *)jarg5; 
  arg6 = (operations_research::RegularLimit *)jarg6; 
  result = (operations_research::LocalSearchPhaseParameters *)(arg1)->MakeLocalSearchPhaseParameters(arg2,arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeLocalSearchPhaseParameters__SWIG_5___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6, void * jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  operations_research::SolutionPool *arg3 = (operations_research::SolutionPool *) (operations_research::SolutionPool *)0 ;
  operations_research::LocalSearchOperator *arg4 = (operations_research::LocalSearchOperator *) (operations_research::LocalSearchOperator *)0 ;
  operations_research::DecisionBuilder *arg5 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::RegularLimit *arg6 = (operations_research::RegularLimit *) (operations_research::RegularLimit *)0 ;
  operations_research::LocalSearchFilterManager *arg7 = (operations_research::LocalSearchFilterManager *) 0 ;
  operations_research::LocalSearchPhaseParameters *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::SolutionPool *)jarg3; 
  arg4 = (operations_research::LocalSearchOperator *)jarg4; 
  arg5 = (operations_research::DecisionBuilder *)jarg5; 
  arg6 = (operations_research::RegularLimit *)jarg6; 
  arg7 = (operations_research::LocalSearchFilterManager *)jarg7; 
  result = (operations_research::LocalSearchPhaseParameters *)(arg1)->MakeLocalSearchPhaseParameters(arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeAcceptFilter___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::LocalSearchFilter *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::LocalSearchFilter *)(arg1)->MakeAcceptFilter();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeRejectFilter___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::LocalSearchFilter *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::LocalSearchFilter *)(arg1)->MakeRejectFilter();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeVariableDomainFilter___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::LocalSearchFilter *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::LocalSearchFilter *)(arg1)->MakeVariableDomainFilter();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSumObjectiveFilter__SWIG_0___(void * jarg1, void * jarg2,  void *  jarg3, int jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Solver::IndexEvaluator2 arg3 ;
  operations_research::Solver::LocalSearchFilterBound arg4 ;
  operations_research::IntVarLocalSearchFilter *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = [jarg3](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg3)(t, u);
  };
  
  arg4 = (operations_research::Solver::LocalSearchFilterBound)jarg4; 
  result = (operations_research::IntVarLocalSearchFilter *)(arg1)->MakeSumObjectiveFilter((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_MakeSumObjectiveFilter__SWIG_1___(void * jarg1, void * jarg2, void * jarg3,  void *  jarg4, int jarg5) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::Solver::IndexEvaluator3 arg4 ;
  operations_research::Solver::LocalSearchFilterBound arg5 ;
  operations_research::IntVarLocalSearchFilter *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg4 = [jarg4](int64_t t, int64_t u, int64_t v) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t, int64_t))jarg4)(t, u, v);
  };
  
  arg5 = (operations_research::Solver::LocalSearchFilterBound)jarg5; 
  result = (operations_research::IntVarLocalSearchFilter *)(arg1)->MakeSumObjectiveFilter((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_TopPeriodicCheck___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->TopPeriodicCheck();
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_TopProgressPercent___(void * jarg1) {
  int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int)(arg1)->TopProgressPercent();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_PushState___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->PushState();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_PopState___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->PopState();
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SearchDepth___(void * jarg1) {
  int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int)((operations_research::Solver const *)arg1)->SearchDepth();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SearchLeftDepth___(void * jarg1) {
  int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int)((operations_research::Solver const *)arg1)->SearchLeftDepth();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SolveDepth___(void * jarg1) {
  int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int)((operations_research::Solver const *)arg1)->SolveDepth();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Rand64___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)(arg1)->Rand64(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Rand32___(void * jarg1, int jarg2) {
  int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int32_t arg2 ;
  int32_t result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int32_t)jarg2; 
  result = (int32_t)(arg1)->Rand32(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ReSeed___(void * jarg1, int jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int32_t arg2 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (int32_t)jarg2; 
  (arg1)->ReSeed(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ExportProfilingOverview___(void * jarg1, char * jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->ExportProfilingOverview((std::string const &)*arg2);
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_LocalSearchProfile___(void * jarg1) {
  char * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = ((operations_research::Solver const *)arg1)->LocalSearchProfile();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CurrentlyInSolve___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (bool)((operations_research::Solver const *)arg1)->CurrentlyInSolve();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Constraints___(void * jarg1) {
  int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  int result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (int)((operations_research::Solver const *)arg1)->constraints();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Accept___(void * jarg1, void * jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::Solver const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_BalancingDecision___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Decision *)((operations_research::Solver const *)arg1)->balancing_decision();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ClearFailIntercept___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->clear_fail_intercept();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_SetUseFastLocalSearch___(void * jarg1, unsigned int jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool arg2 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->SetUseFastLocalSearch(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_UseFastLocalSearch___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (bool)((operations_research::Solver const *)arg1)->UseFastLocalSearch();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_HasName___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::PropagationBaseObject *arg2 = (operations_research::PropagationBaseObject *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::PropagationBaseObject *)jarg2; 
  result = (bool)((operations_research::Solver const *)arg1)->HasName((operations_research::PropagationBaseObject const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RegisterDemon___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  operations_research::Demon *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  result = (operations_research::Demon *)(arg1)->RegisterDemon(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RegisterIntExpr___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntExpr *)(arg1)->RegisterIntExpr(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RegisterIntVar___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (operations_research::IntVar *)(arg1)->RegisterIntVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RegisterIntervalVar___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVar *)(arg1)->RegisterIntervalVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_Cache___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::ModelCache *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::ModelCache *)((operations_research::Solver const *)arg1)->Cache();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_InstrumentsDemons___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (bool)((operations_research::Solver const *)arg1)->InstrumentsDemons();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IsProfilingEnabled___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (bool)((operations_research::Solver const *)arg1)->IsProfilingEnabled();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_IsLocalSearchProfilingEnabled___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (bool)((operations_research::Solver const *)arg1)->IsLocalSearchProfilingEnabled();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_InstrumentsVariables___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (bool)((operations_research::Solver const *)arg1)->InstrumentsVariables();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_NameAllVariables___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  bool result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (bool)((operations_research::Solver const *)arg1)->NameAllVariables();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ModelName___(void * jarg1) {
  char * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = ((operations_research::Solver const *)arg1)->model_name();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_GetPropagationMonitor___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::PropagationMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::PropagationMonitor *)((operations_research::Solver const *)arg1)->GetPropagationMonitor();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_AddPropagationMonitor___(void * jarg1, void * jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::PropagationMonitor *arg2 = (operations_research::PropagationMonitor *) (operations_research::PropagationMonitor *)0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::PropagationMonitor *)jarg2; 
  (arg1)->AddPropagationMonitor(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_GetLocalSearchMonitor___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::LocalSearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::LocalSearchMonitor *)((operations_research::Solver const *)arg1)->GetLocalSearchMonitor();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_AddLocalSearchMonitor___(void * jarg1, void * jarg2) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::LocalSearchMonitor *arg2 = (operations_research::LocalSearchMonitor *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::LocalSearchMonitor *)jarg2; 
  (arg1)->AddLocalSearchMonitor(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_GetOrCreateLocalSearchState___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Assignment *)(arg1)->GetOrCreateLocalSearchState();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ClearLocalSearchState___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->ClearLocalSearchState();
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CastExpression___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (operations_research::IntExpr *)((operations_research::Solver const *)arg1)->CastExpression((operations_research::IntVar const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_FinishCurrentSearch___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->FinishCurrentSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_RestartCurrentSearch___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->RestartCurrentSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_ShouldFail___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->ShouldFail();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Solver_CheckFail___(void * jarg1) {
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  (arg1)->CheckFail();
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Zero___() {
  long long jresult ;
  int64_t result;
  
  result = (int64_t)operations_research::Zero();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_One___() {
  long long jresult ;
  int64_t result;
  
  result = (int64_t)operations_research::One();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_BaseObject___() {
  void * jresult ;
  operations_research::BaseObject *result = 0 ;
  
  result = (operations_research::BaseObject *)new operations_research::BaseObject();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_BaseObject___(void * jarg1) {
  operations_research::BaseObject *arg1 = (operations_research::BaseObject *) 0 ;
  
  arg1 = (operations_research::BaseObject *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseObject_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::BaseObject *arg1 = (operations_research::BaseObject *) 0 ;
  std::string result;
  
  arg1 = (operations_research::BaseObject *)jarg1; 
  result = ((operations_research::BaseObject const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_PropagationBaseObject___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::PropagationBaseObject *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::PropagationBaseObject *)new operations_research::PropagationBaseObject(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_PropagationBaseObject___(void * jarg1) {
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  std::string result;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  result = ((operations_research::PropagationBaseObject const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_solver___(void * jarg1) {
  void * jresult ;
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  operations_research::Solver *result = 0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  result = (operations_research::Solver *)((operations_research::PropagationBaseObject const *)arg1)->solver();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_FreezeQueue___(void * jarg1) {
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  (arg1)->FreezeQueue();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_UnfreezeQueue___(void * jarg1) {
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  (arg1)->UnfreezeQueue();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_EnqueueDelayedDemon___(void * jarg1, void * jarg2) {
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->EnqueueDelayedDemon(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_EnqueueVar___(void * jarg1, void * jarg2) {
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->EnqueueVar(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_ResetActionOnFail___(void * jarg1) {
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  (arg1)->reset_action_on_fail();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_SetVariableToCleanOnFail___(void * jarg1, void * jarg2) {
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->set_variable_to_clean_on_fail(arg2);
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_Name___(void * jarg1) {
  char * jresult ;
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  std::string result;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  result = ((operations_research::PropagationBaseObject const *)arg1)->name();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_SetName___(void * jarg1, char * jarg2) {
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->set_name((std::string const &)*arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_HasName___(void * jarg1) {
  unsigned int jresult ;
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  bool result;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  result = (bool)((operations_research::PropagationBaseObject const *)arg1)->HasName();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_BaseName___(void * jarg1) {
  char * jresult ;
  operations_research::PropagationBaseObject *arg1 = (operations_research::PropagationBaseObject *) 0 ;
  std::string result;
  
  arg1 = (operations_research::PropagationBaseObject *)jarg1; 
  result = ((operations_research::PropagationBaseObject const *)arg1)->BaseName();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Decision___() {
  void * jresult ;
  operations_research::Decision *result = 0 ;
  
  result = (operations_research::Decision *)new SwigDirector_Decision();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Decision___(void * jarg1) {
  operations_research::Decision *arg1 = (operations_research::Decision *) 0 ;
  
  arg1 = (operations_research::Decision *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Decision_ApplyWrapper___(void * jarg1, void * jarg2) {
  operations_research::Decision *arg1 = (operations_research::Decision *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  
  arg1 = (operations_research::Decision *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  (arg1)->Apply(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Decision_RefuteWrapper___(void * jarg1, void * jarg2) {
  operations_research::Decision *arg1 = (operations_research::Decision *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  
  arg1 = (operations_research::Decision *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  (arg1)->Refute(arg2);
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Decision_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::Decision *arg1 = (operations_research::Decision *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Decision *)jarg1; 
  result = ((operations_research::Decision const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Decision_ToStringSwigExplicitDecision___(void * jarg1) {
  char * jresult ;
  operations_research::Decision *arg1 = (operations_research::Decision *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Decision *)jarg1; 
  result = ((operations_research::Decision const *)arg1)->operations_research::Decision::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Decision_Accept___(void * jarg1, void * jarg2) {
  operations_research::Decision *arg1 = (operations_research::Decision *) 0 ;
  operations_research::DecisionVisitor *arg2 = (operations_research::DecisionVisitor *) (operations_research::DecisionVisitor *)0 ;
  
  arg1 = (operations_research::Decision *)jarg1; 
  arg2 = (operations_research::DecisionVisitor *)jarg2; 
  ((operations_research::Decision const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Decision_AcceptSwigExplicitDecision___(void * jarg1, void * jarg2) {
  operations_research::Decision *arg1 = (operations_research::Decision *) 0 ;
  operations_research::DecisionVisitor *arg2 = (operations_research::DecisionVisitor *) (operations_research::DecisionVisitor *)0 ;
  
  arg1 = (operations_research::Decision *)jarg1; 
  arg2 = (operations_research::DecisionVisitor *)jarg2; 
  ((operations_research::Decision const *)arg1)->operations_research::Decision::Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Decision_director_connect___(void *objarg, SwigDirector_Decision::SWIG_Callback0_t callback0, SwigDirector_Decision::SWIG_Callback1_t callback1, SwigDirector_Decision::SWIG_Callback2_t callback2, SwigDirector_Decision::SWIG_Callback3_t callback3) {
  operations_research::Decision *obj = (operations_research::Decision *)objarg;
  SwigDirector_Decision *director = static_cast<SwigDirector_Decision *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_DecisionVisitor___() {
  void * jresult ;
  operations_research::DecisionVisitor *result = 0 ;
  
  result = (operations_research::DecisionVisitor *)new operations_research::DecisionVisitor();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_DecisionVisitor___(void * jarg1) {
  operations_research::DecisionVisitor *arg1 = (operations_research::DecisionVisitor *) 0 ;
  
  arg1 = (operations_research::DecisionVisitor *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionVisitor_VisitSetVariableValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::DecisionVisitor *arg1 = (operations_research::DecisionVisitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::DecisionVisitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->VisitSetVariableValue(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionVisitor_VisitSplitVariableDomain___(void * jarg1, void * jarg2, long long jarg3, unsigned int jarg4) {
  operations_research::DecisionVisitor *arg1 = (operations_research::DecisionVisitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  bool arg4 ;
  
  arg1 = (operations_research::DecisionVisitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = jarg4 ? true : false; 
  (arg1)->VisitSplitVariableDomain(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionVisitor_VisitScheduleOrPostpone___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::DecisionVisitor *arg1 = (operations_research::DecisionVisitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::DecisionVisitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->VisitScheduleOrPostpone(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionVisitor_VisitScheduleOrExpedite___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::DecisionVisitor *arg1 = (operations_research::DecisionVisitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::DecisionVisitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->VisitScheduleOrExpedite(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionVisitor_VisitRankFirstInterval___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::DecisionVisitor *arg1 = (operations_research::DecisionVisitor *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  int arg3 ;
  
  arg1 = (operations_research::DecisionVisitor *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->VisitRankFirstInterval(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionVisitor_VisitRankLastInterval___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::DecisionVisitor *arg1 = (operations_research::DecisionVisitor *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  int arg3 ;
  
  arg1 = (operations_research::DecisionVisitor *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->VisitRankLastInterval(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionVisitor_VisitUnknownDecision___(void * jarg1) {
  operations_research::DecisionVisitor *arg1 = (operations_research::DecisionVisitor *) 0 ;
  
  arg1 = (operations_research::DecisionVisitor *)jarg1; 
  (arg1)->VisitUnknownDecision();
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_DecisionBuilder___() {
  void * jresult ;
  operations_research::DecisionBuilder *result = 0 ;
  
  result = (operations_research::DecisionBuilder *)new SwigDirector_DecisionBuilder();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_DecisionBuilder___(void * jarg1) {
  operations_research::DecisionBuilder *arg1 = (operations_research::DecisionBuilder *) 0 ;
  
  arg1 = (operations_research::DecisionBuilder *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilder_NextWrapper___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::DecisionBuilder *arg1 = (operations_research::DecisionBuilder *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::Decision *result = 0 ;
  
  arg1 = (operations_research::DecisionBuilder *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  result = (operations_research::Decision *)(arg1)->Next(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilder_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::DecisionBuilder *arg1 = (operations_research::DecisionBuilder *) 0 ;
  std::string result;
  
  arg1 = (operations_research::DecisionBuilder *)jarg1; 
  result = ((operations_research::DecisionBuilder const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilder_ToStringSwigExplicitDecisionBuilder___(void * jarg1) {
  char * jresult ;
  operations_research::DecisionBuilder *arg1 = (operations_research::DecisionBuilder *) 0 ;
  std::string result;
  
  arg1 = (operations_research::DecisionBuilder *)jarg1; 
  result = ((operations_research::DecisionBuilder const *)arg1)->operations_research::DecisionBuilder::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilder_director_connect___(void *objarg, SwigDirector_DecisionBuilder::SWIG_Callback0_t callback0, SwigDirector_DecisionBuilder::SWIG_Callback1_t callback1) {
  operations_research::DecisionBuilder *obj = (operations_research::DecisionBuilder *)objarg;
  SwigDirector_DecisionBuilder *director = static_cast<SwigDirector_DecisionBuilder *>(obj);
  director->swig_connect_director(callback0, callback1);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Demon___() {
  void * jresult ;
  operations_research::Demon *result = 0 ;
  
  result = (operations_research::Demon *)new SwigDirector_Demon();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Demon___(void * jarg1) {
  operations_research::Demon *arg1 = (operations_research::Demon *) 0 ;
  
  arg1 = (operations_research::Demon *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_RunWrapper___(void * jarg1, void * jarg2) {
  operations_research::Demon *arg1 = (operations_research::Demon *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  
  arg1 = (operations_research::Demon *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  (arg1)->Run(arg2);
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_Priority___(void * jarg1) {
  int jresult ;
  operations_research::Demon *arg1 = (operations_research::Demon *) 0 ;
  operations_research::Solver::DemonPriority result;
  
  arg1 = (operations_research::Demon *)jarg1; 
  result = (operations_research::Solver::DemonPriority)((operations_research::Demon const *)arg1)->priority();
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_PrioritySwigExplicitDemon___(void * jarg1) {
  int jresult ;
  operations_research::Demon *arg1 = (operations_research::Demon *) 0 ;
  operations_research::Solver::DemonPriority result;
  
  arg1 = (operations_research::Demon *)jarg1; 
  result = (operations_research::Solver::DemonPriority)((operations_research::Demon const *)arg1)->operations_research::Demon::priority();
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::Demon *arg1 = (operations_research::Demon *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Demon *)jarg1; 
  result = ((operations_research::Demon const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_ToStringSwigExplicitDemon___(void * jarg1) {
  char * jresult ;
  operations_research::Demon *arg1 = (operations_research::Demon *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Demon *)jarg1; 
  result = ((operations_research::Demon const *)arg1)->operations_research::Demon::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_Inhibit___(void * jarg1, void * jarg2) {
  operations_research::Demon *arg1 = (operations_research::Demon *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  
  arg1 = (operations_research::Demon *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  (arg1)->inhibit(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_Desinhibit___(void * jarg1, void * jarg2) {
  operations_research::Demon *arg1 = (operations_research::Demon *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  
  arg1 = (operations_research::Demon *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  (arg1)->desinhibit(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_director_connect___(void *objarg, SwigDirector_Demon::SWIG_Callback0_t callback0, SwigDirector_Demon::SWIG_Callback1_t callback1, SwigDirector_Demon::SWIG_Callback2_t callback2) {
  operations_research::Demon *obj = (operations_research::Demon *)objarg;
  SwigDirector_Demon *director = static_cast<SwigDirector_Demon *>(obj);
  director->swig_connect_director(callback0, callback1, callback2);
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kAbs_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kAbs;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kAbsEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kAbsEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kAllDifferent_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kAllDifferent;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kAllowedAssignments_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kAllowedAssignments;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kAtMost_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kAtMost;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIndexOf_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIndexOf;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kBetween_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kBetween;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kConditionalExpr_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kConditionalExpr;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCircuit_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCircuit;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kConvexPiecewise_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kConvexPiecewise;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCountEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCountEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCover_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCover;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCumulative_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCumulative;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDeviation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDeviation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDifference_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDifference;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDisjunctive_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDisjunctive;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDistribute_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDistribute;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDivide_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDivide;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDurationExpr_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDurationExpr;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kElement_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kElement;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kElementEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kElementEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kEndExpr_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kEndExpr;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kEquality_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kEquality;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kFalseConstraint_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kFalseConstraint;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kGlobalCardinality_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kGlobalCardinality;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kGreater_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kGreater;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kGreaterOrEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kGreaterOrEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIntegerVariable_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIntegerVariable;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIntervalBinaryRelation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIntervalBinaryRelation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIntervalDisjunction_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIntervalDisjunction;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIntervalUnaryRelation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIntervalUnaryRelation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIntervalVariable_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIntervalVariable;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kInversePermutation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kInversePermutation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIsBetween_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIsBetween;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIsDifferent_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIsDifferent;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIsEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIsEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIsGreater_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIsGreater;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIsGreaterOrEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIsGreaterOrEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIsLess_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIsLess;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIsLessOrEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIsLessOrEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIsMember_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIsMember;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kLess_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kLess;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kLessOrEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kLessOrEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kLexLess_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kLexLess;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kLinkExprVar_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kLinkExprVar;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMapDomain_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMapDomain;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMax_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMax;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMaxEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMaxEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMember_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMember;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMin_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMin;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMinEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMinEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kModulo_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kModulo;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kNoCycle_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kNoCycle;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kNonEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kNonEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kNotBetween_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kNotBetween;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kNotMember_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kNotMember;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kNullIntersect_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kNullIntersect;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kOpposite_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kOpposite;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kPack_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kPack;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kPathCumul_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kPathCumul;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDelayedPathCumul_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDelayedPathCumul;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kPerformedExpr_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kPerformedExpr;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kPower_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kPower;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kProduct_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kProduct;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kScalProd_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kScalProd;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kScalProdEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kScalProdEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kScalProdGreaterOrEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kScalProdGreaterOrEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kScalProdLessOrEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kScalProdLessOrEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSemiContinuous_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSemiContinuous;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSequenceVariable_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSequenceVariable;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSortingConstraint_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSortingConstraint;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSquare_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSquare;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kStartExpr_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kStartExpr;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSum_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSum;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSumEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSumEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSumGreaterOrEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSumGreaterOrEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSumLessOrEqual_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSumLessOrEqual;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kTrace_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kTrace;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kTransition_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kTransition;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kTrueConstraint_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kTrueConstraint;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kVarBoundWatcher_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kVarBoundWatcher;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kVarValueWatcher_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kVarValueWatcher;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCountAssignedItemsExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCountAssignedItemsExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCountUsedBinsExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCountUsedBinsExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kInt64ToBoolExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kInt64ToBoolExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kInt64ToInt64Extension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kInt64ToInt64Extension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kObjectiveExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kObjectiveExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSearchLimitExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSearchLimitExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kUsageEqualVariableExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kUsageEqualVariableExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kUsageLessConstantExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kUsageLessConstantExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kVariableGroupExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kVariableGroupExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kVariableUsageLessConstantExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kVariableUsageLessConstantExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kWeightedSumOfAssignedEqualVariableExtension_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kWeightedSumOfAssignedEqualVariableExtension;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kActiveArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kActiveArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kAssumePathsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kAssumePathsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kBranchesLimitArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kBranchesLimitArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCapacityArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCapacityArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCardsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCardsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCoefficientsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCoefficientsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCountArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCountArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCumulativeArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCumulativeArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kCumulsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kCumulsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDemandsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDemandsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDurationMaxArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDurationMaxArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDurationMinArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDurationMinArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kEarlyCostArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kEarlyCostArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kEarlyDateArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kEarlyDateArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kEndMaxArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kEndMaxArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kEndMinArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kEndMinArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kEndsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kEndsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kExpressionArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kExpressionArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kFailuresLimitArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kFailuresLimitArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kFinalStatesArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kFinalStatesArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kFixedChargeArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kFixedChargeArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIndex2Argument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIndex2Argument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIndexArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIndexArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kInitialState_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kInitialState;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIntervalArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIntervalArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kIntervalsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kIntervalsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kLateCostArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kLateCostArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kLateDateArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kLateDateArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kLeftArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kLeftArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMaxArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMaxArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMaximizeArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMaximizeArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMinArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMinArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kModuloArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kModuloArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kNextsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kNextsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kOptionalArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kOptionalArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kPartialArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kPartialArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kPositionXArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kPositionXArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kPositionYArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kPositionYArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kRangeArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kRangeArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kRelationArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kRelationArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kRightArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kRightArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSequenceArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSequenceArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSequencesArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSequencesArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSizeArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSizeArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSizeXArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSizeXArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSizeYArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSizeYArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSmartTimeCheckArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSmartTimeCheckArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSolutionLimitArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSolutionLimitArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kStartMaxArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kStartMaxArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kStartMinArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kStartMinArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kStartsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kStartsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kStepArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kStepArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kTargetArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kTargetArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kTimeLimitArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kTimeLimitArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kTransitsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kTransitsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kTuplesArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kTuplesArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kValueArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kValueArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kValuesArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kValuesArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kVariableArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kVariableArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kVarsArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kVarsArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kEvaluatorArgument_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kEvaluatorArgument;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kMirrorOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kMirrorOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kRelaxedMaxOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kRelaxedMaxOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kRelaxedMinOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kRelaxedMinOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kSumOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kSumOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kDifferenceOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kDifferenceOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kProductOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kProductOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kStartSyncOnStartOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kStartSyncOnStartOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kStartSyncOnEndOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kStartSyncOnEndOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_kTraceOperation_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::ModelVisitor::kTraceOperation;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_ModelVisitor___(void * jarg1) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_BeginVisitModel___(void * jarg1, char * jarg2) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->BeginVisitModel((std::string const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_EndVisitModel___(void * jarg1, char * jarg2) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->EndVisitModel((std::string const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_BeginVisitConstraint___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::Constraint *arg3 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (operations_research::Constraint *)jarg3; 
  (arg1)->BeginVisitConstraint((std::string const &)*arg2,(operations_research::Constraint const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_EndVisitConstraint___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::Constraint *arg3 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (operations_research::Constraint *)jarg3; 
  (arg1)->EndVisitConstraint((std::string const &)*arg2,(operations_research::Constraint const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_BeginVisitExtension___(void * jarg1, char * jarg2) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->BeginVisitExtension((std::string const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_EndVisitExtension___(void * jarg1, char * jarg2) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->EndVisitExtension((std::string const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_BeginVisitIntegerExpression___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  (arg1)->BeginVisitIntegerExpression((std::string const &)*arg2,(operations_research::IntExpr const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_EndVisitIntegerExpression___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  (arg1)->EndVisitIntegerExpression((std::string const &)*arg2,(operations_research::IntExpr const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntegerVariable__SWIG_0___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  (arg1)->VisitIntegerVariable((operations_research::IntVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntegerVariable__SWIG_1___(void * jarg1, void * jarg2, char * jarg3, long long jarg4, void * jarg5) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::string *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::IntVar *arg5 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::IntVar *)jarg5; 
  (arg1)->VisitIntegerVariable((operations_research::IntVar const *)arg2,(std::string const &)*arg3,arg4,arg5);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntervalVariable___(void * jarg1, void * jarg2, char * jarg3, long long jarg4, void * jarg5) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  std::string *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::IntervalVar *arg5 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::IntervalVar *)jarg5; 
  (arg1)->VisitIntervalVariable((operations_research::IntervalVar const *)arg2,(std::string const &)*arg3,arg4,arg5);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitSequenceVariable___(void * jarg1, void * jarg2) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  (arg1)->VisitSequenceVariable((operations_research::SequenceVar const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntegerArgument___(void * jarg1, char * jarg2, long long jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (int64_t)jarg3; 
  (arg1)->VisitIntegerArgument((std::string const &)*arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntegerArrayArgument___(void * jarg1, char * jarg2,  int length3, int64_t*  jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->VisitIntegerArrayArgument((std::string const &)*arg2,(std::vector< int64_t > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntegerMatrixArgument___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::IntTupleSet *arg3 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (operations_research::IntTupleSet *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::IntTupleSet const & type is null", 0);
    return ;
  } 
  (arg1)->VisitIntegerMatrixArgument((std::string const &)*arg2,(operations_research::IntTupleSet const &)*arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntegerExpressionArgument___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  (arg1)->VisitIntegerExpressionArgument((std::string const &)*arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntegerVariableArrayArgument___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->VisitIntegerVariableArrayArgument((std::string const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntervalArgument___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  (arg1)->VisitIntervalArgument((std::string const &)*arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitIntervalArrayArgument___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< operations_research::IntervalVar * > *arg3 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< operations_research::IntervalVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->VisitIntervalArrayArgument((std::string const &)*arg2,(std::vector< operations_research::IntervalVar * > const &)*arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitSequenceArgument___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::SequenceVar *arg3 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (operations_research::SequenceVar *)jarg3; 
  (arg1)->VisitSequenceArgument((std::string const &)*arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_VisitSequenceArrayArgument___(void * jarg1, char * jarg2, void * jarg3) {
  operations_research::ModelVisitor *arg1 = (operations_research::ModelVisitor *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< operations_research::SequenceVar * > *arg3 = 0 ;
  
  arg1 = (operations_research::ModelVisitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  arg3 = (std::vector< operations_research::SequenceVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->VisitSequenceArrayArgument((std::string const &)*arg2,(std::vector< operations_research::SequenceVar * > const &)*arg3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_ModelVisitor___() {
  void * jresult ;
  operations_research::ModelVisitor *result = 0 ;
  
  result = (operations_research::ModelVisitor *)new operations_research::ModelVisitor();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Constraint___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Constraint *)new SwigDirector_Constraint(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Constraint___(void * jarg1) {
  operations_research::Constraint *arg1 = (operations_research::Constraint *) 0 ;
  
  arg1 = (operations_research::Constraint *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_Post___(void * jarg1) {
  operations_research::Constraint *arg1 = (operations_research::Constraint *) 0 ;
  
  arg1 = (operations_research::Constraint *)jarg1; 
  (arg1)->Post();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_InitialPropagateWrapper___(void * jarg1) {
  operations_research::Constraint *arg1 = (operations_research::Constraint *) 0 ;
  
  arg1 = (operations_research::Constraint *)jarg1; 
  (arg1)->InitialPropagate();
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::Constraint *arg1 = (operations_research::Constraint *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Constraint *)jarg1; 
  result = ((operations_research::Constraint const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_ToStringSwigExplicitConstraint___(void * jarg1) {
  char * jresult ;
  operations_research::Constraint *arg1 = (operations_research::Constraint *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Constraint *)jarg1; 
  result = ((operations_research::Constraint const *)arg1)->operations_research::Constraint::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_Accept___(void * jarg1, void * jarg2) {
  operations_research::Constraint *arg1 = (operations_research::Constraint *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::Constraint *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::Constraint const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_IsCastConstraint___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Constraint *arg1 = (operations_research::Constraint *) 0 ;
  bool result;
  
  arg1 = (operations_research::Constraint *)jarg1; 
  result = (bool)((operations_research::Constraint const *)arg1)->IsCastConstraint();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_Var___(void * jarg1) {
  void * jresult ;
  operations_research::Constraint *arg1 = (operations_research::Constraint *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Constraint *)jarg1; 
  result = (operations_research::IntVar *)(arg1)->Var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_director_connect___(void *objarg, SwigDirector_Constraint::SWIG_Callback0_t callback0, SwigDirector_Constraint::SWIG_Callback1_t callback1, SwigDirector_Constraint::SWIG_Callback2_t callback2, SwigDirector_Constraint::SWIG_Callback3_t callback3, SwigDirector_Constraint::SWIG_Callback4_t callback4) {
  operations_research::Constraint *obj = (operations_research::Constraint *)objarg;
  SwigDirector_Constraint *director = static_cast<SwigDirector_Constraint *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_CastConstraint___(void * jarg1) {
  operations_research::CastConstraint *arg1 = (operations_research::CastConstraint *) 0 ;
  
  arg1 = (operations_research::CastConstraint *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_CastConstraint_TargetVar___(void * jarg1) {
  void * jresult ;
  operations_research::CastConstraint *arg1 = (operations_research::CastConstraint *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::CastConstraint *)jarg1; 
  result = (operations_research::IntVar *)((operations_research::CastConstraint const *)arg1)->target_var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_kNoProgress_get___() {
  int jresult ;
  int result;
  
  result = (int)operations_research::SearchMonitor::kNoProgress;
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SearchMonitor___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::SearchMonitor *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::SearchMonitor *)new SwigDirector_SearchMonitor(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_EnterSearch___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->EnterSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_EnterSearchSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::EnterSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_RestartSearch___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->RestartSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_RestartSearchSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::RestartSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_ExitSearch___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->ExitSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_ExitSearchSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::ExitSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_BeginNextDecision___(void * jarg1, void * jarg2) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  (arg1)->BeginNextDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_BeginNextDecisionSwigExplicitSearchMonitor___(void * jarg1, void * jarg2) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  (arg1)->operations_research::SearchMonitor::BeginNextDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_EndNextDecision___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::Decision *arg3 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::Decision *)jarg3; 
  (arg1)->EndNextDecision(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_EndNextDecisionSwigExplicitSearchMonitor___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  operations_research::Decision *arg3 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  arg3 = (operations_research::Decision *)jarg3; 
  (arg1)->operations_research::SearchMonitor::EndNextDecision(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_ApplyDecision___(void * jarg1, void * jarg2) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->ApplyDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_ApplyDecisionSwigExplicitSearchMonitor___(void * jarg1, void * jarg2) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->operations_research::SearchMonitor::ApplyDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_RefuteDecision___(void * jarg1, void * jarg2) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->RefuteDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_RefuteDecisionSwigExplicitSearchMonitor___(void * jarg1, void * jarg2) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->operations_research::SearchMonitor::RefuteDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AfterDecision___(void * jarg1, void * jarg2, unsigned int jarg3) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  bool arg3 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  arg3 = jarg3 ? true : false; 
  (arg1)->AfterDecision(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AfterDecisionSwigExplicitSearchMonitor___(void * jarg1, void * jarg2, unsigned int jarg3) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  bool arg3 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  arg3 = jarg3 ? true : false; 
  (arg1)->operations_research::SearchMonitor::AfterDecision(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_BeginFail___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->BeginFail();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_BeginFailSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::BeginFail();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_EndFail___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->EndFail();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_EndFailSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::EndFail();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_BeginInitialPropagation___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->BeginInitialPropagation();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_BeginInitialPropagationSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::BeginInitialPropagation();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_EndInitialPropagation___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->EndInitialPropagation();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_EndInitialPropagationSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::EndInitialPropagation();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptSolution___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (bool)(arg1)->AcceptSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptSolutionSwigExplicitSearchMonitor___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (bool)(arg1)->operations_research::SearchMonitor::AcceptSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AtSolution___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (bool)(arg1)->AtSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AtSolutionSwigExplicitSearchMonitor___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (bool)(arg1)->operations_research::SearchMonitor::AtSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_NoMoreSolutions___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->NoMoreSolutions();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_NoMoreSolutionsSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::NoMoreSolutions();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_LocalOptimum___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (bool)(arg1)->LocalOptimum();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_LocalOptimumSwigExplicitSearchMonitor___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (bool)(arg1)->operations_research::SearchMonitor::LocalOptimum();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptDelta___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  result = (bool)(arg1)->AcceptDelta(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptDeltaSwigExplicitSearchMonitor___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  result = (bool)(arg1)->operations_research::SearchMonitor::AcceptDelta(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptNeighbor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->AcceptNeighbor();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptNeighborSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::AcceptNeighbor();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptUncheckedNeighbor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->AcceptUncheckedNeighbor();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptUncheckedNeighborSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::AcceptUncheckedNeighbor();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_IsUncheckedSolutionLimitReached___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (bool)(arg1)->IsUncheckedSolutionLimitReached();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_IsUncheckedSolutionLimitReachedSwigExplicitSearchMonitor___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (bool)(arg1)->operations_research::SearchMonitor::IsUncheckedSolutionLimitReached();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_solver___(void * jarg1) {
  void * jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::Solver *result = 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (operations_research::Solver *)((operations_research::SearchMonitor const *)arg1)->solver();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_PeriodicCheck___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->PeriodicCheck();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_PeriodicCheckSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::PeriodicCheck();
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_ProgressPercent___(void * jarg1) {
  int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  int result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (int)(arg1)->ProgressPercent();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_ProgressPercentSwigExplicitSearchMonitor___(void * jarg1) {
  int jresult ;
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  int result;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  result = (int)(arg1)->operations_research::SearchMonitor::ProgressPercent();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_Accept___(void * jarg1, void * jarg2) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::SearchMonitor const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_AcceptSwigExplicitSearchMonitor___(void * jarg1, void * jarg2) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::SearchMonitor const *)arg1)->operations_research::SearchMonitor::Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_Install___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->Install();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_InstallSwigExplicitSearchMonitor___(void * jarg1) {
  operations_research::SearchMonitor *arg1 = (operations_research::SearchMonitor *) 0 ;
  
  arg1 = (operations_research::SearchMonitor *)jarg1; 
  (arg1)->operations_research::SearchMonitor::Install();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_director_connect___(void *objarg, SwigDirector_SearchMonitor::SWIG_Callback0_t callback0, SwigDirector_SearchMonitor::SWIG_Callback1_t callback1, SwigDirector_SearchMonitor::SWIG_Callback2_t callback2, SwigDirector_SearchMonitor::SWIG_Callback3_t callback3, SwigDirector_SearchMonitor::SWIG_Callback4_t callback4, SwigDirector_SearchMonitor::SWIG_Callback5_t callback5, SwigDirector_SearchMonitor::SWIG_Callback6_t callback6, SwigDirector_SearchMonitor::SWIG_Callback7_t callback7, SwigDirector_SearchMonitor::SWIG_Callback8_t callback8, SwigDirector_SearchMonitor::SWIG_Callback9_t callback9, SwigDirector_SearchMonitor::SWIG_Callback10_t callback10, SwigDirector_SearchMonitor::SWIG_Callback11_t callback11, SwigDirector_SearchMonitor::SWIG_Callback12_t callback12, SwigDirector_SearchMonitor::SWIG_Callback13_t callback13, SwigDirector_SearchMonitor::SWIG_Callback14_t callback14, SwigDirector_SearchMonitor::SWIG_Callback15_t callback15, SwigDirector_SearchMonitor::SWIG_Callback16_t callback16, SwigDirector_SearchMonitor::SWIG_Callback17_t callback17, SwigDirector_SearchMonitor::SWIG_Callback18_t callback18, SwigDirector_SearchMonitor::SWIG_Callback19_t callback19, SwigDirector_SearchMonitor::SWIG_Callback20_t callback20, SwigDirector_SearchMonitor::SWIG_Callback21_t callback21, SwigDirector_SearchMonitor::SWIG_Callback22_t callback22, SwigDirector_SearchMonitor::SWIG_Callback23_t callback23, SwigDirector_SearchMonitor::SWIG_Callback24_t callback24) {
  operations_research::SearchMonitor *obj = (operations_research::SearchMonitor *)objarg;
  SwigDirector_SearchMonitor *director = static_cast<SwigDirector_SearchMonitor *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntExpr___(void * jarg1) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Min___(void * jarg1) {
  long long jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  result = (int64_t)((operations_research::IntExpr const *)arg1)->Min();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_SetMin___(void * jarg1, long long jarg2) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetMin(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Max___(void * jarg1) {
  long long jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  result = (int64_t)((operations_research::IntExpr const *)arg1)->Max();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_SetMax___(void * jarg1, long long jarg2) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetMax(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Range___(void * jarg1, long * jarg2, long * jarg3) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t *arg2 = (int64_t *) 0 ;
  int64_t *arg3 = (int64_t *) 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t *)jarg2; 
  arg3 = (int64_t *)jarg3; 
  (arg1)->Range(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_SetRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetRange(arg2,arg3);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_SetValue___(void * jarg1, long long jarg2) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetValue(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Bound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  result = (bool)((operations_research::IntExpr const *)arg1)->Bound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsVar___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  result = (bool)((operations_research::IntExpr const *)arg1)->IsVar();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Var___(void * jarg1) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  result = (operations_research::IntVar *)(arg1)->Var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_VarWithName___(void * jarg1, char * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (operations_research::IntVar *)(arg1)->VarWithName((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_WhenRange__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_WhenRange__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Accept___(void * jarg1, void * jarg2) {
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::IntExpr const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_MapTo___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Constraint *)operations_research_IntExpr_MapTo(arg1,(std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IndexOf__SWIG_0___(void * jarg1,  int length2, int64_t*  jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (operations_research::IntExpr *)operations_research_IntExpr_IndexOf__SWIG_0(arg1,(std::vector< long > const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IndexOf__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::IntExpr *)operations_research_IntExpr_IndexOf__SWIG_1(arg1,(std::vector< operations_research::IntVar * > const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsEqual__SWIG_0___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsEqual__SWIG_0(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsDifferent__SWIG_0___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsDifferent__SWIG_0(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsGreater__SWIG_0___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsGreater__SWIG_0(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsGreaterOrEqual__SWIG_0___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsGreaterOrEqual__SWIG_0(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsLess__SWIG_0___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsLess__SWIG_0(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsLessOrEqual__SWIG_0___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsLessOrEqual__SWIG_0(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsMember__SWIG_0___(void * jarg1,  int length2, int64_t*  jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (operations_research::IntVar *)operations_research_IntExpr_IsMember__SWIG_0(arg1,(std::vector< long > const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsMember__SWIG_1___(void * jarg1,  int length2, int*  jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  std::vector< int > *arg2 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (operations_research::IntVar *)operations_research_IntExpr_IsMember__SWIG_1(arg1,(std::vector< int > const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Member__SWIG_0___(void * jarg1,  int length2, int64_t*  jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (operations_research::Constraint *)operations_research_IntExpr_Member__SWIG_0(arg1,(std::vector< long > const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Member__SWIG_1___(void * jarg1,  int length2, int*  jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  std::vector< int > *arg2 = 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (operations_research::Constraint *)operations_research_IntExpr_Member__SWIG_1(arg1,(std::vector< int > const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsEqual__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsEqual__SWIG_1(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsDifferent__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsDifferent__SWIG_1(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsGreater__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsGreater__SWIG_1(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsGreaterOrEqual__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsGreaterOrEqual__SWIG_1(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsLess__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsLess__SWIG_1(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_IsLessOrEqual__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  result = (operations_research::IntVar *)operations_research_IntExpr_IsLessOrEqual__SWIG_1(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Minimize___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::OptimizeVar *)operations_research_IntExpr_Minimize(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_Maximize___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntExpr *arg1 = (operations_research::IntExpr *) 0 ;
  int64_t arg2 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::IntExpr *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::OptimizeVar *)operations_research_IntExpr_Maximize(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVarIterator___(void * jarg1) {
  operations_research::IntVarIterator *arg1 = (operations_research::IntVarIterator *) 0 ;
  
  arg1 = (operations_research::IntVarIterator *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarIterator_Init___(void * jarg1) {
  operations_research::IntVarIterator *arg1 = (operations_research::IntVarIterator *) 0 ;
  
  arg1 = (operations_research::IntVarIterator *)jarg1; 
  (arg1)->Init();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarIterator_Ok___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntVarIterator *arg1 = (operations_research::IntVarIterator *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntVarIterator *)jarg1; 
  result = (bool)((operations_research::IntVarIterator const *)arg1)->Ok();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarIterator_Value___(void * jarg1) {
  long long jresult ;
  operations_research::IntVarIterator *arg1 = (operations_research::IntVarIterator *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntVarIterator *)jarg1; 
  result = (int64_t)((operations_research::IntVarIterator const *)arg1)->Value();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarIterator_Next___(void * jarg1) {
  operations_research::IntVarIterator *arg1 = (operations_research::IntVarIterator *) 0 ;
  
  arg1 = (operations_research::IntVarIterator *)jarg1; 
  (arg1)->Next();
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarIterator_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::IntVarIterator *arg1 = (operations_research::IntVarIterator *) 0 ;
  std::string result;
  
  arg1 = (operations_research::IntVarIterator *)jarg1; 
  result = ((operations_research::IntVarIterator const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVar___(void * jarg1) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_IsVar___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (bool)((operations_research::IntVar const *)arg1)->IsVar();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_Var___(void * jarg1) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (operations_research::IntVar *)(arg1)->Var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_Value___(void * jarg1) {
  long long jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (int64_t)((operations_research::IntVar const *)arg1)->Value();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_RemoveValue___(void * jarg1, long long jarg2) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->RemoveValue(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_RemoveInterval___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->RemoveInterval(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_RemoveValues___(void * jarg1,  int length2, int64_t*  jarg2) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->RemoveValues((std::vector< int64_t > const &)*arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_SetValues___(void * jarg1,  int length2, int64_t*  jarg2) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  (arg1)->SetValues((std::vector< int64_t > const &)*arg2);
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_WhenBound__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenBound(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_WhenBound__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenBound(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_WhenDomain__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenDomain(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_WhenDomain__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenDomain(arg2);
}
 
 
SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_Size___(void * jarg1) {
  unsigned long long jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  uint64_t result;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (uint64_t)((operations_research::IntVar const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_Contains___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (bool)((operations_research::IntVar const *)arg1)->Contains(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_OldMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (int64_t)((operations_research::IntVar const *)arg1)->OldMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_OldMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (int64_t)((operations_research::IntVar const *)arg1)->OldMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_VarType___(void * jarg1) {
  int jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int result;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (int)((operations_research::IntVar const *)arg1)->VarType();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_Accept___(void * jarg1, void * jarg2) {
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::IntVar const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_IsEqual___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->IsEqual(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_IsDifferent___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->IsDifferent(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_IsGreaterOrEqual___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->IsGreaterOrEqual(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_IsLessOrEqual___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->IsLessOrEqual(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_Index___(void * jarg1) {
  int jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  int result;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (int)((operations_research::IntVar const *)arg1)->index();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_GetDomain___(void * jarg1) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  operations_research::IntVarIterator *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (operations_research::IntVarIterator *)operations_research_IntVar_GetDomain(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_GetHoles___(void * jarg1) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) 0 ;
  operations_research::IntVarIterator *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (operations_research::IntVarIterator *)operations_research_IntVar_GetHoles(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SolutionCollector__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (operations_research::SolutionCollector *)new SwigDirector_SolutionCollector(arg1,(operations_research::Assignment const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SolutionCollector__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::SolutionCollector *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::SolutionCollector *)new SwigDirector_SolutionCollector(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SolutionCollector___(void * jarg1) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  std::string result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  result = ((operations_research::SolutionCollector const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_ToStringSwigExplicitSolutionCollector___(void * jarg1) {
  char * jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  std::string result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  result = ((operations_research::SolutionCollector const *)arg1)->operations_research::SolutionCollector::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Add__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->Add(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Add__SWIG_1___(void * jarg1, void * jarg2) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->Add((std::vector< operations_research::IntVar * > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Add__SWIG_2___(void * jarg1, void * jarg2) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  (arg1)->Add(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Add__SWIG_3___(void * jarg1, void * jarg2) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->Add((std::vector< operations_research::IntervalVar * > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Add__SWIG_4___(void * jarg1, void * jarg2) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  (arg1)->Add(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Add__SWIG_5___(void * jarg1, void * jarg2) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  std::vector< operations_research::SequenceVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (std::vector< operations_research::SequenceVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->Add((std::vector< operations_research::SequenceVar * > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_AddObjective___(void * jarg1, void * jarg2) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->AddObjective(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_EnterSearch___(void * jarg1) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  (arg1)->EnterSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_EnterSearchSwigExplicitSolutionCollector___(void * jarg1) {
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  (arg1)->operations_research::SolutionCollector::EnterSearch();
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_SolutionCount___(void * jarg1) {
  int jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  result = (int)((operations_research::SolutionCollector const *)arg1)->solution_count();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Solution___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::Assignment *)((operations_research::SolutionCollector const *)arg1)->solution(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_WallTime___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->wall_time(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Branches___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->branches(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Failures___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->failures(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_ObjectiveValue___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->objective_value(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Value___(void * jarg1, int jarg2, void * jarg3) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->Value(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_StartValue___(void * jarg1, int jarg2, void * jarg3) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->StartValue(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_EndValue___(void * jarg1, int jarg2, void * jarg3) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->EndValue(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_DurationValue___(void * jarg1, int jarg2, void * jarg3) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->DurationValue(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_PerformedValue___(void * jarg1, int jarg2, void * jarg3) {
  long long jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::IntervalVar *arg3 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::IntervalVar *)jarg3; 
  result = (int64_t)((operations_research::SolutionCollector const *)arg1)->PerformedValue(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_ForwardSequence___(void * jarg1, int jarg2, void * jarg3) {
  void* jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::SequenceVar *arg3 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::SequenceVar *)jarg3; 
  result = (std::vector< int > *) &((operations_research::SolutionCollector const *)arg1)->ForwardSequence(arg2,arg3);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_BackwardSequence___(void * jarg1, int jarg2, void * jarg3) {
  void* jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::SequenceVar *arg3 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::SequenceVar *)jarg3; 
  result = (std::vector< int > *) &((operations_research::SolutionCollector const *)arg1)->BackwardSequence(arg2,arg3);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_Unperformed___(void * jarg1, int jarg2, void * jarg3) {
  void* jresult ;
  operations_research::SolutionCollector *arg1 = (operations_research::SolutionCollector *) 0 ;
  int arg2 ;
  operations_research::SequenceVar *arg3 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::SolutionCollector *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (operations_research::SequenceVar *)jarg3; 
  result = (std::vector< int > *) &((operations_research::SolutionCollector const *)arg1)->Unperformed(arg2,arg3);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_director_connect___(void *objarg, SwigDirector_SolutionCollector::SWIG_Callback0_t callback0, SwigDirector_SolutionCollector::SWIG_Callback1_t callback1, SwigDirector_SolutionCollector::SWIG_Callback2_t callback2, SwigDirector_SolutionCollector::SWIG_Callback3_t callback3, SwigDirector_SolutionCollector::SWIG_Callback4_t callback4, SwigDirector_SolutionCollector::SWIG_Callback5_t callback5, SwigDirector_SolutionCollector::SWIG_Callback6_t callback6, SwigDirector_SolutionCollector::SWIG_Callback7_t callback7, SwigDirector_SolutionCollector::SWIG_Callback8_t callback8, SwigDirector_SolutionCollector::SWIG_Callback9_t callback9, SwigDirector_SolutionCollector::SWIG_Callback10_t callback10, SwigDirector_SolutionCollector::SWIG_Callback11_t callback11, SwigDirector_SolutionCollector::SWIG_Callback12_t callback12, SwigDirector_SolutionCollector::SWIG_Callback13_t callback13, SwigDirector_SolutionCollector::SWIG_Callback14_t callback14, SwigDirector_SolutionCollector::SWIG_Callback15_t callback15, SwigDirector_SolutionCollector::SWIG_Callback16_t callback16, SwigDirector_SolutionCollector::SWIG_Callback17_t callback17, SwigDirector_SolutionCollector::SWIG_Callback18_t callback18, SwigDirector_SolutionCollector::SWIG_Callback19_t callback19, SwigDirector_SolutionCollector::SWIG_Callback20_t callback20, SwigDirector_SolutionCollector::SWIG_Callback21_t callback21, SwigDirector_SolutionCollector::SWIG_Callback22_t callback22, SwigDirector_SolutionCollector::SWIG_Callback23_t callback23, SwigDirector_SolutionCollector::SWIG_Callback24_t callback24) {
  operations_research::SolutionCollector *obj = (operations_research::SolutionCollector *)objarg;
  SwigDirector_SolutionCollector *director = static_cast<SwigDirector_SolutionCollector *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_OptimizeVar___(void * jarg1, unsigned int jarg2, void * jarg3, long long jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  bool arg2 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  operations_research::OptimizeVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (operations_research::OptimizeVar *)new SwigDirector_OptimizeVar(arg1,arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_OptimizeVar___(void * jarg1) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_Best___(void * jarg1) {
  long long jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = (int64_t)((operations_research::OptimizeVar const *)arg1)->best();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_Var___(void * jarg1) {
  void * jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = (operations_research::IntVar *)((operations_research::OptimizeVar const *)arg1)->Var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_AcceptDelta___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  result = (bool)(arg1)->AcceptDelta(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_AcceptDeltaSwigExplicitOptimizeVar___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  result = (bool)(arg1)->operations_research::OptimizeVar::AcceptDelta(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_EnterSearch___(void * jarg1) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  (arg1)->EnterSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_EnterSearchSwigExplicitOptimizeVar___(void * jarg1) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  (arg1)->operations_research::OptimizeVar::EnterSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_BeginNextDecision___(void * jarg1, void * jarg2) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  (arg1)->BeginNextDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_BeginNextDecisionSwigExplicitOptimizeVar___(void * jarg1, void * jarg2) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  (arg1)->operations_research::OptimizeVar::BeginNextDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_RefuteDecision___(void * jarg1, void * jarg2) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->RefuteDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_RefuteDecisionSwigExplicitOptimizeVar___(void * jarg1, void * jarg2) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->operations_research::OptimizeVar::RefuteDecision(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_AtSolution___(void * jarg1) {
  unsigned int jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = (bool)(arg1)->AtSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_AtSolutionSwigExplicitOptimizeVar___(void * jarg1) {
  unsigned int jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = (bool)(arg1)->operations_research::OptimizeVar::AtSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_AcceptSolution___(void * jarg1) {
  unsigned int jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = (bool)(arg1)->AcceptSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_AcceptSolutionSwigExplicitOptimizeVar___(void * jarg1) {
  unsigned int jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = (bool)(arg1)->operations_research::OptimizeVar::AcceptSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_Print___(void * jarg1) {
  char * jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  std::string result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = ((operations_research::OptimizeVar const *)arg1)->Print();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_PrintSwigExplicitOptimizeVar___(void * jarg1) {
  char * jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  std::string result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = ((operations_research::OptimizeVar const *)arg1)->operations_research::OptimizeVar::Print();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  std::string result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = ((operations_research::OptimizeVar const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_ToStringSwigExplicitOptimizeVar___(void * jarg1) {
  char * jresult ;
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  std::string result;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  result = ((operations_research::OptimizeVar const *)arg1)->operations_research::OptimizeVar::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_Accept___(void * jarg1, void * jarg2) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::OptimizeVar const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_AcceptSwigExplicitOptimizeVar___(void * jarg1, void * jarg2) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::OptimizeVar const *)arg1)->operations_research::OptimizeVar::Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_ApplyBound___(void * jarg1) {
  operations_research::OptimizeVar *arg1 = (operations_research::OptimizeVar *) 0 ;
  
  arg1 = (operations_research::OptimizeVar *)jarg1; 
  (arg1)->ApplyBound();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_director_connect___(void *objarg, SwigDirector_OptimizeVar::SWIG_Callback0_t callback0, SwigDirector_OptimizeVar::SWIG_Callback1_t callback1, SwigDirector_OptimizeVar::SWIG_Callback2_t callback2, SwigDirector_OptimizeVar::SWIG_Callback3_t callback3, SwigDirector_OptimizeVar::SWIG_Callback4_t callback4, SwigDirector_OptimizeVar::SWIG_Callback5_t callback5, SwigDirector_OptimizeVar::SWIG_Callback6_t callback6, SwigDirector_OptimizeVar::SWIG_Callback7_t callback7, SwigDirector_OptimizeVar::SWIG_Callback8_t callback8, SwigDirector_OptimizeVar::SWIG_Callback9_t callback9, SwigDirector_OptimizeVar::SWIG_Callback10_t callback10, SwigDirector_OptimizeVar::SWIG_Callback11_t callback11, SwigDirector_OptimizeVar::SWIG_Callback12_t callback12, SwigDirector_OptimizeVar::SWIG_Callback13_t callback13, SwigDirector_OptimizeVar::SWIG_Callback14_t callback14, SwigDirector_OptimizeVar::SWIG_Callback15_t callback15, SwigDirector_OptimizeVar::SWIG_Callback16_t callback16, SwigDirector_OptimizeVar::SWIG_Callback17_t callback17, SwigDirector_OptimizeVar::SWIG_Callback18_t callback18, SwigDirector_OptimizeVar::SWIG_Callback19_t callback19, SwigDirector_OptimizeVar::SWIG_Callback20_t callback20, SwigDirector_OptimizeVar::SWIG_Callback21_t callback21, SwigDirector_OptimizeVar::SWIG_Callback22_t callback22, SwigDirector_OptimizeVar::SWIG_Callback23_t callback23, SwigDirector_OptimizeVar::SWIG_Callback24_t callback24, SwigDirector_OptimizeVar::SWIG_Callback25_t callback25) {
  operations_research::OptimizeVar *obj = (operations_research::OptimizeVar *)objarg;
  SwigDirector_OptimizeVar *director = static_cast<SwigDirector_OptimizeVar *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SearchLimit___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::SearchLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::SearchLimit *)new SwigDirector_SearchLimit(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SearchLimit___(void * jarg1) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_IsCrossed___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  result = (bool)((operations_research::SearchLimit const *)arg1)->crossed();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_Check___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  result = (bool)(arg1)->Check();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_Init___(void * jarg1) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  (arg1)->Init();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_Copy___(void * jarg1, void * jarg2) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  operations_research::SearchLimit *arg2 = (operations_research::SearchLimit *) (operations_research::SearchLimit *)0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  arg2 = (operations_research::SearchLimit *)jarg2; 
  (arg1)->Copy((operations_research::SearchLimit const *)arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_MakeClone___(void * jarg1) {
  void * jresult ;
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  operations_research::SearchLimit *result = 0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  result = (operations_research::SearchLimit *)((operations_research::SearchLimit const *)arg1)->MakeClone();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_EnterSearch___(void * jarg1) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  (arg1)->EnterSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_EnterSearchSwigExplicitSearchLimit___(void * jarg1) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  (arg1)->operations_research::SearchLimit::EnterSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_BeginNextDecision___(void * jarg1, void * jarg2) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  (arg1)->BeginNextDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_BeginNextDecisionSwigExplicitSearchLimit___(void * jarg1, void * jarg2) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  operations_research::DecisionBuilder *arg2 = (operations_research::DecisionBuilder *) (operations_research::DecisionBuilder *)0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  arg2 = (operations_research::DecisionBuilder *)jarg2; 
  (arg1)->operations_research::SearchLimit::BeginNextDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_PeriodicCheck___(void * jarg1) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  (arg1)->PeriodicCheck();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_PeriodicCheckSwigExplicitSearchLimit___(void * jarg1) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  (arg1)->operations_research::SearchLimit::PeriodicCheck();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_RefuteDecision___(void * jarg1, void * jarg2) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->RefuteDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_RefuteDecisionSwigExplicitSearchLimit___(void * jarg1, void * jarg2) {
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->operations_research::SearchLimit::RefuteDecision(arg2);
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  std::string result;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  result = ((operations_research::SearchLimit const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_ToStringSwigExplicitSearchLimit___(void * jarg1) {
  char * jresult ;
  operations_research::SearchLimit *arg1 = (operations_research::SearchLimit *) 0 ;
  std::string result;
  
  arg1 = (operations_research::SearchLimit *)jarg1; 
  result = ((operations_research::SearchLimit const *)arg1)->operations_research::SearchLimit::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_director_connect___(void *objarg, SwigDirector_SearchLimit::SWIG_Callback0_t callback0, SwigDirector_SearchLimit::SWIG_Callback1_t callback1, SwigDirector_SearchLimit::SWIG_Callback2_t callback2, SwigDirector_SearchLimit::SWIG_Callback3_t callback3, SwigDirector_SearchLimit::SWIG_Callback4_t callback4, SwigDirector_SearchLimit::SWIG_Callback5_t callback5, SwigDirector_SearchLimit::SWIG_Callback6_t callback6, SwigDirector_SearchLimit::SWIG_Callback7_t callback7, SwigDirector_SearchLimit::SWIG_Callback8_t callback8, SwigDirector_SearchLimit::SWIG_Callback9_t callback9, SwigDirector_SearchLimit::SWIG_Callback10_t callback10, SwigDirector_SearchLimit::SWIG_Callback11_t callback11, SwigDirector_SearchLimit::SWIG_Callback12_t callback12, SwigDirector_SearchLimit::SWIG_Callback13_t callback13, SwigDirector_SearchLimit::SWIG_Callback14_t callback14, SwigDirector_SearchLimit::SWIG_Callback15_t callback15, SwigDirector_SearchLimit::SWIG_Callback16_t callback16, SwigDirector_SearchLimit::SWIG_Callback17_t callback17, SwigDirector_SearchLimit::SWIG_Callback18_t callback18, SwigDirector_SearchLimit::SWIG_Callback19_t callback19, SwigDirector_SearchLimit::SWIG_Callback20_t callback20, SwigDirector_SearchLimit::SWIG_Callback21_t callback21, SwigDirector_SearchLimit::SWIG_Callback22_t callback22, SwigDirector_SearchLimit::SWIG_Callback23_t callback23, SwigDirector_SearchLimit::SWIG_Callback24_t callback24, SwigDirector_SearchLimit::SWIG_Callback25_t callback25, SwigDirector_SearchLimit::SWIG_Callback26_t callback26, SwigDirector_SearchLimit::SWIG_Callback27_t callback27, SwigDirector_SearchLimit::SWIG_Callback28_t callback28) {
  operations_research::SearchLimit *obj = (operations_research::SearchLimit *)objarg;
  SwigDirector_SearchLimit *director = static_cast<SwigDirector_SearchLimit *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25, callback26, callback27, callback28);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RegularLimit___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, long long jarg5, unsigned int jarg6, unsigned int jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  absl::Duration arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  bool arg6 ;
  bool arg7 ;
  absl::Duration *argp2 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  argp2 = (absl::Duration *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null absl::Duration", 0);
    return 0;
  }
  arg2 = *argp2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = jarg6 ? true : false; 
  arg7 = jarg7 ? true : false; 
  result = (operations_research::RegularLimit *)new SwigDirector_RegularLimit(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RegularLimit___(void * jarg1) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_Copy___(void * jarg1, void * jarg2) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  operations_research::SearchLimit *arg2 = (operations_research::SearchLimit *) (operations_research::SearchLimit *)0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  arg2 = (operations_research::SearchLimit *)jarg2; 
  (arg1)->Copy((operations_research::SearchLimit const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_CopySwigExplicitRegularLimit___(void * jarg1, void * jarg2) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  operations_research::SearchLimit *arg2 = (operations_research::SearchLimit *) (operations_research::SearchLimit *)0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  arg2 = (operations_research::SearchLimit *)jarg2; 
  (arg1)->operations_research::RegularLimit::Copy((operations_research::SearchLimit const *)arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_MakeClone___(void * jarg1) {
  void * jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  operations_research::SearchLimit *result = 0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (operations_research::SearchLimit *)((operations_research::RegularLimit const *)arg1)->MakeClone();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_MakeCloneSwigExplicitRegularLimit___(void * jarg1) {
  void * jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  operations_research::SearchLimit *result = 0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (operations_research::SearchLimit *)((operations_research::RegularLimit const *)arg1)->operations_research::RegularLimit::MakeClone();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_MakeIdenticalClone___(void * jarg1) {
  void * jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  operations_research::RegularLimit *result = 0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (operations_research::RegularLimit *)((operations_research::RegularLimit const *)arg1)->MakeIdenticalClone();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_Check___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  bool result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (bool)(arg1)->Check();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_CheckSwigExplicitRegularLimit___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  bool result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (bool)(arg1)->operations_research::RegularLimit::Check();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_Init___(void * jarg1) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  (arg1)->Init();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_InitSwigExplicitRegularLimit___(void * jarg1) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  (arg1)->operations_research::RegularLimit::Init();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_ExitSearch___(void * jarg1) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  (arg1)->ExitSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_ExitSearchSwigExplicitRegularLimit___(void * jarg1) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  (arg1)->operations_research::RegularLimit::ExitSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_UpdateLimits___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, long long jarg5) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  absl::Duration arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t arg5 ;
  absl::Duration *argp2 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  argp2 = (absl::Duration *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null absl::Duration", 0);
    return ;
  }
  arg2 = *argp2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  (arg1)->UpdateLimits(arg2,arg3,arg4,arg5);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_WallTime___(void * jarg1) {
  long long jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (int64_t)((operations_research::RegularLimit const *)arg1)->wall_time();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_Branches___(void * jarg1) {
  long long jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (int64_t)((operations_research::RegularLimit const *)arg1)->branches();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_Failures___(void * jarg1) {
  long long jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (int64_t)((operations_research::RegularLimit const *)arg1)->failures();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_Solutions___(void * jarg1) {
  long long jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (int64_t)((operations_research::RegularLimit const *)arg1)->solutions();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_IsUncheckedSolutionLimitReached___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  bool result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (bool)(arg1)->IsUncheckedSolutionLimitReached();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_IsUncheckedSolutionLimitReachedSwigExplicitRegularLimit___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  bool result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (bool)(arg1)->operations_research::RegularLimit::IsUncheckedSolutionLimitReached();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_ProgressPercent___(void * jarg1) {
  int jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  int result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (int)(arg1)->ProgressPercent();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_ProgressPercentSwigExplicitRegularLimit___(void * jarg1) {
  int jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  int result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = (int)(arg1)->operations_research::RegularLimit::ProgressPercent();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  std::string result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = ((operations_research::RegularLimit const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_ToStringSwigExplicitRegularLimit___(void * jarg1) {
  char * jresult ;
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  std::string result;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  result = ((operations_research::RegularLimit const *)arg1)->operations_research::RegularLimit::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_Accept___(void * jarg1, void * jarg2) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::RegularLimit const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_AcceptSwigExplicitRegularLimit___(void * jarg1, void * jarg2) {
  operations_research::RegularLimit *arg1 = (operations_research::RegularLimit *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::RegularLimit *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::RegularLimit const *)arg1)->operations_research::RegularLimit::Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_director_connect___(void *objarg, SwigDirector_RegularLimit::SWIG_Callback0_t callback0, SwigDirector_RegularLimit::SWIG_Callback1_t callback1, SwigDirector_RegularLimit::SWIG_Callback2_t callback2, SwigDirector_RegularLimit::SWIG_Callback3_t callback3, SwigDirector_RegularLimit::SWIG_Callback4_t callback4, SwigDirector_RegularLimit::SWIG_Callback5_t callback5, SwigDirector_RegularLimit::SWIG_Callback6_t callback6, SwigDirector_RegularLimit::SWIG_Callback7_t callback7, SwigDirector_RegularLimit::SWIG_Callback8_t callback8, SwigDirector_RegularLimit::SWIG_Callback9_t callback9, SwigDirector_RegularLimit::SWIG_Callback10_t callback10, SwigDirector_RegularLimit::SWIG_Callback11_t callback11, SwigDirector_RegularLimit::SWIG_Callback12_t callback12, SwigDirector_RegularLimit::SWIG_Callback13_t callback13, SwigDirector_RegularLimit::SWIG_Callback14_t callback14, SwigDirector_RegularLimit::SWIG_Callback15_t callback15, SwigDirector_RegularLimit::SWIG_Callback16_t callback16, SwigDirector_RegularLimit::SWIG_Callback17_t callback17, SwigDirector_RegularLimit::SWIG_Callback18_t callback18, SwigDirector_RegularLimit::SWIG_Callback19_t callback19, SwigDirector_RegularLimit::SWIG_Callback20_t callback20, SwigDirector_RegularLimit::SWIG_Callback21_t callback21, SwigDirector_RegularLimit::SWIG_Callback22_t callback22, SwigDirector_RegularLimit::SWIG_Callback23_t callback23, SwigDirector_RegularLimit::SWIG_Callback24_t callback24, SwigDirector_RegularLimit::SWIG_Callback25_t callback25, SwigDirector_RegularLimit::SWIG_Callback26_t callback26, SwigDirector_RegularLimit::SWIG_Callback27_t callback27, SwigDirector_RegularLimit::SWIG_Callback28_t callback28) {
  operations_research::RegularLimit *obj = (operations_research::RegularLimit *)objarg;
  SwigDirector_RegularLimit *director = static_cast<SwigDirector_RegularLimit *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25, callback26, callback27, callback28);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_ImprovementSearchLimit___(void * jarg1, void * jarg2, unsigned int jarg3, double jarg4, double jarg5, double jarg6, int jarg7) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  bool arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  operations_research::ImprovementSearchLimit *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (double)jarg4; 
  arg5 = (double)jarg5; 
  arg6 = (double)jarg6; 
  arg7 = (int)jarg7; 
  result = (operations_research::ImprovementSearchLimit *)new operations_research::ImprovementSearchLimit(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_ImprovementSearchLimit___(void * jarg1) {
  operations_research::ImprovementSearchLimit *arg1 = (operations_research::ImprovementSearchLimit *) 0 ;
  
  arg1 = (operations_research::ImprovementSearchLimit *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ImprovementSearchLimit_Copy___(void * jarg1, void * jarg2) {
  operations_research::ImprovementSearchLimit *arg1 = (operations_research::ImprovementSearchLimit *) 0 ;
  operations_research::SearchLimit *arg2 = (operations_research::SearchLimit *) (operations_research::SearchLimit *)0 ;
  
  arg1 = (operations_research::ImprovementSearchLimit *)jarg1; 
  arg2 = (operations_research::SearchLimit *)jarg2; 
  (arg1)->Copy((operations_research::SearchLimit const *)arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ImprovementSearchLimit_MakeClone___(void * jarg1) {
  void * jresult ;
  operations_research::ImprovementSearchLimit *arg1 = (operations_research::ImprovementSearchLimit *) 0 ;
  operations_research::SearchLimit *result = 0 ;
  
  arg1 = (operations_research::ImprovementSearchLimit *)jarg1; 
  result = (operations_research::SearchLimit *)((operations_research::ImprovementSearchLimit const *)arg1)->MakeClone();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ImprovementSearchLimit_Check___(void * jarg1) {
  unsigned int jresult ;
  operations_research::ImprovementSearchLimit *arg1 = (operations_research::ImprovementSearchLimit *) 0 ;
  bool result;
  
  arg1 = (operations_research::ImprovementSearchLimit *)jarg1; 
  result = (bool)(arg1)->Check();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ImprovementSearchLimit_AtSolution___(void * jarg1) {
  unsigned int jresult ;
  operations_research::ImprovementSearchLimit *arg1 = (operations_research::ImprovementSearchLimit *) 0 ;
  bool result;
  
  arg1 = (operations_research::ImprovementSearchLimit *)jarg1; 
  result = (bool)(arg1)->AtSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ImprovementSearchLimit_Init___(void * jarg1) {
  operations_research::ImprovementSearchLimit *arg1 = (operations_research::ImprovementSearchLimit *) 0 ;
  
  arg1 = (operations_research::ImprovementSearchLimit *)jarg1; 
  (arg1)->Init();
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_kMinValidValue_get___() {
  long long jresult ;
  int64_t result;
  
  result = (int64_t)(int64_t)operations_research::IntervalVar::kMinValidValue;
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_kMaxValidValue_get___() {
  long long jresult ;
  int64_t result;
  
  result = (int64_t)(int64_t)operations_research::IntervalVar::kMaxValidValue;
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntervalVar___(void * jarg1) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->StartMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->StartMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetStartMin___(void * jarg1, long long jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetStartMin(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetStartMax___(void * jarg1, long long jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetStartMax(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetStartRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetStartRange(arg2,arg3);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_OldStartMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->OldStartMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_OldStartMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->OldStartMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenStartRange__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenStartRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenStartRange__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenStartRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenStartBound__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenStartBound(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenStartBound__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenStartBound(arg2);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_DurationMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->DurationMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_DurationMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->DurationMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetDurationMin___(void * jarg1, long long jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetDurationMin(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetDurationMax___(void * jarg1, long long jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetDurationMax(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetDurationRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetDurationRange(arg2,arg3);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_OldDurationMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->OldDurationMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_OldDurationMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->OldDurationMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenDurationRange__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenDurationRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenDurationRange__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenDurationRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenDurationBound__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenDurationBound(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenDurationBound__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenDurationBound(arg2);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->EndMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->EndMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetEndMin___(void * jarg1, long long jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetEndMin(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetEndMax___(void * jarg1, long long jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetEndMax(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetEndRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetEndRange(arg2,arg3);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_OldEndMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->OldEndMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_OldEndMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (int64_t)((operations_research::IntervalVar const *)arg1)->OldEndMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenEndRange__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenEndRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenEndRange__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenEndRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenEndBound__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenEndBound(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenEndBound__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenEndBound(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_MustBePerformed___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (bool)((operations_research::IntervalVar const *)arg1)->MustBePerformed();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_MayBePerformed___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (bool)((operations_research::IntervalVar const *)arg1)->MayBePerformed();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_CannotBePerformed___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (bool)((operations_research::IntervalVar const *)arg1)->CannotBePerformed();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_IsPerformedBound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (bool)((operations_research::IntervalVar const *)arg1)->IsPerformedBound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SetPerformed___(void * jarg1, unsigned int jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  bool arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetPerformed(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WasPerformedBound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (bool)((operations_research::IntervalVar const *)arg1)->WasPerformedBound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenPerformedBound__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenPerformedBound(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenPerformedBound__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenPerformedBound(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenAnything__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenAnything(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_WhenAnything__SWIG_1___(void * jarg1,  void *  jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::Solver::Closure arg2 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->WhenAnything(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartExpr___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (operations_research::IntExpr *)(arg1)->StartExpr();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_DurationExpr___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (operations_research::IntExpr *)(arg1)->DurationExpr();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndExpr___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (operations_research::IntExpr *)(arg1)->EndExpr();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_PerformedExpr___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (operations_research::IntExpr *)(arg1)->PerformedExpr();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SafeStartExpr___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntExpr *)(arg1)->SafeStartExpr(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SafeDurationExpr___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntExpr *)(arg1)->SafeDurationExpr(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SafeEndExpr___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntExpr *)(arg1)->SafeEndExpr(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_Accept___(void * jarg1, void * jarg2) {
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::IntervalVar const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAfterEnd___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAfterEnd(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAfterStart___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAfterStart(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAtEnd___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAtEnd(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAtStart___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAtStart(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAfterEnd___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAfterEnd(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAfterStart___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAfterStart(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAtEnd___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAtEnd(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAtStart___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAtStart(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAfterEndWithDelay___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAfterEndWithDelay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAfterStartWithDelay___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAfterStartWithDelay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAtEndWithDelay___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAtEndWithDelay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAtStartWithDelay___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAtStartWithDelay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAfterEndWithDelay___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAfterEndWithDelay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAfterStartWithDelay___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAfterStartWithDelay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAtEndWithDelay___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAtEndWithDelay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAtStartWithDelay___(void * jarg1, void * jarg2, long long jarg3) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int64_t arg3 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAtStartWithDelay(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAfter___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAfter(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsAt___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsAt(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_EndsBefore___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_EndsBefore(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAfter___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAfter(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsAt___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsAt(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_StartsBefore___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_StartsBefore(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_CrossesDate___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_CrossesDate(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_AvoidsDate___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  int64_t arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::Constraint *)operations_research_IntervalVar_AvoidsDate(arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_RelaxedMax___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (operations_research::IntervalVar *)operations_research_IntervalVar_RelaxedMax(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_RelaxedMin___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (operations_research::IntervalVar *)operations_research_IntervalVar_RelaxedMin(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SequenceVar___(void * jarg1, void * jarg2, void * jarg3, char * jarg4) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  operations_research::SequenceVar *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  if (!jarg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg4_str(jarg4);
  arg4 = &arg4_str; 
  result = (operations_research::SequenceVar *)new operations_research::SequenceVar(arg1,(std::vector< operations_research::IntervalVar * > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::string const &)*arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SequenceVar___(void * jarg1) {
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  std::string result;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  result = ((operations_research::SequenceVar const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_RankFirst___(void * jarg1, int jarg2) {
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->RankFirst(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_RankNotFirst___(void * jarg1, int jarg2) {
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->RankNotFirst(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_RankLast___(void * jarg1, int jarg2) {
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->RankLast(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_RankNotLast___(void * jarg1, int jarg2) {
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->RankNotLast(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_RankSequence___(void * jarg1,  int length2, int*  jarg2,  int length3, int*  jarg3,  int length4, int*  jarg4) {
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  std::vector< int > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  (arg1)->RankSequence((std::vector< int > const &)*arg2,(std::vector< int > const &)*arg3,(std::vector< int > const &)*arg4);
  {
    delete arg2; 
  }
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_Interval___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  int arg2 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::IntervalVar *)((operations_research::SequenceVar const *)arg1)->Interval(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_Next___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  int arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::IntVar *)((operations_research::SequenceVar const *)arg1)->Next(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_Size___(void * jarg1) {
  long long jresult ;
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  result = (int64_t)((operations_research::SequenceVar const *)arg1)->size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_Accept___(void * jarg1, void * jarg2) {
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::SequenceVar const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_AssignmentElement___() {
  void * jresult ;
  operations_research::AssignmentElement *result = 0 ;
  
  result = (operations_research::AssignmentElement *)new operations_research::AssignmentElement();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentElement_Activate___(void * jarg1) {
  operations_research::AssignmentElement *arg1 = (operations_research::AssignmentElement *) 0 ;
  
  arg1 = (operations_research::AssignmentElement *)jarg1; 
  (arg1)->Activate();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentElement_Deactivate___(void * jarg1) {
  operations_research::AssignmentElement *arg1 = (operations_research::AssignmentElement *) 0 ;
  
  arg1 = (operations_research::AssignmentElement *)jarg1; 
  (arg1)->Deactivate();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentElement_Activated___(void * jarg1) {
  unsigned int jresult ;
  operations_research::AssignmentElement *arg1 = (operations_research::AssignmentElement *) 0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentElement *)jarg1; 
  result = (bool)((operations_research::AssignmentElement const *)arg1)->Activated();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_AssignmentElement___(void * jarg1) {
  operations_research::AssignmentElement *arg1 = (operations_research::AssignmentElement *) 0 ;
  
  arg1 = (operations_research::AssignmentElement *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarElement__SWIG_0___() {
  void * jresult ;
  operations_research::IntVarElement *result = 0 ;
  
  result = (operations_research::IntVarElement *)new operations_research::IntVarElement();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarElement__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::IntVar *arg1 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::IntVar *)jarg1; 
  result = (operations_research::IntVarElement *)new operations_research::IntVarElement(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Reset___(void * jarg1, void * jarg2) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->Reset(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Clone___(void * jarg1) {
  void * jresult ;
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  result = (operations_research::IntVarElement *)(arg1)->Clone();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Copy___(void * jarg1, void * jarg2) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  operations_research::IntVarElement *arg2 = 0 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  arg2 = (operations_research::IntVarElement *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::IntVarElement const & type is null", 0);
    return ;
  } 
  (arg1)->Copy((operations_research::IntVarElement const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Var___(void * jarg1) {
  void * jresult ;
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  result = (operations_research::IntVar *)((operations_research::IntVarElement const *)arg1)->Var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Store___(void * jarg1) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  (arg1)->Store();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Restore___(void * jarg1) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  (arg1)->Restore();
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Min___(void * jarg1) {
  long long jresult ;
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntVarElement const *)arg1)->Min();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_SetMin___(void * jarg1, long long jarg2) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetMin(arg2);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Max___(void * jarg1) {
  long long jresult ;
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntVarElement const *)arg1)->Max();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_SetMax___(void * jarg1, long long jarg2) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetMax(arg2);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Value___(void * jarg1) {
  long long jresult ;
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntVarElement const *)arg1)->Value();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_Bound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  result = (bool)((operations_research::IntVarElement const *)arg1)->Bound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_SetRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetRange(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_SetValue___(void * jarg1, long long jarg2) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetValue(arg2);
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  std::string result;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  result = ((operations_research::IntVarElement const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVarElement___(void * jarg1) {
  operations_research::IntVarElement *arg1 = (operations_research::IntVarElement *) 0 ;
  
  arg1 = (operations_research::IntVarElement *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntervalVarElement__SWIG_0___() {
  void * jresult ;
  operations_research::IntervalVarElement *result = 0 ;
  
  result = (operations_research::IntervalVarElement *)new operations_research::IntervalVarElement();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntervalVarElement__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVar *arg1 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::IntervalVar *)jarg1; 
  result = (operations_research::IntervalVarElement *)new operations_research::IntervalVarElement(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_Reset___(void * jarg1, void * jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  (arg1)->Reset(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_Clone___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (operations_research::IntervalVarElement *)(arg1)->Clone();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_Copy___(void * jarg1, void * jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  operations_research::IntervalVarElement *arg2 = 0 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (operations_research::IntervalVarElement *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::IntervalVarElement const & type is null", 0);
    return ;
  } 
  (arg1)->Copy((operations_research::IntervalVarElement const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_Var___(void * jarg1) {
  void * jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  operations_research::IntervalVar *result = 0 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (operations_research::IntervalVar *)((operations_research::IntervalVarElement const *)arg1)->Var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_Store___(void * jarg1) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  (arg1)->Store();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_Restore___(void * jarg1) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  (arg1)->Restore();
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_StartMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->StartMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_StartMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->StartMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_StartValue___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->StartValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_DurationMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->DurationMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_DurationMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->DurationMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_DurationValue___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->DurationValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_EndMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->EndMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_EndMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->EndMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_EndValue___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->EndValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_PerformedMin___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->PerformedMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_PerformedMax___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->PerformedMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_PerformedValue___(void * jarg1) {
  long long jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (int64_t)((operations_research::IntervalVarElement const *)arg1)->PerformedValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetStartMin___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetStartMin(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetStartMax___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetStartMax(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetStartRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetStartRange(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetStartValue___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetStartValue(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetDurationMin___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetDurationMin(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetDurationMax___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetDurationMax(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetDurationRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetDurationRange(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetDurationValue___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetDurationValue(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetEndMin___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetEndMin(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetEndMax___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetEndMax(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetEndRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetEndRange(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetEndValue___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetEndValue(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetPerformedMin___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetPerformedMin(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetPerformedMax___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetPerformedMax(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetPerformedRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetPerformedRange(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SetPerformedValue___(void * jarg1, long long jarg2) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetPerformedValue(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_Bound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  bool result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = (bool)((operations_research::IntervalVarElement const *)arg1)->Bound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  std::string result;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  result = ((operations_research::IntervalVarElement const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntervalVarElement___(void * jarg1) {
  operations_research::IntervalVarElement *arg1 = (operations_research::IntervalVarElement *) 0 ;
  
  arg1 = (operations_research::IntervalVarElement *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SequenceVarElement__SWIG_0___() {
  void * jresult ;
  operations_research::SequenceVarElement *result = 0 ;
  
  result = (operations_research::SequenceVarElement *)new operations_research::SequenceVarElement();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SequenceVarElement__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::SequenceVar *arg1 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::SequenceVar *)jarg1; 
  result = (operations_research::SequenceVarElement *)new operations_research::SequenceVarElement(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_Reset___(void * jarg1, void * jarg2) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  (arg1)->Reset(arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_Clone___(void * jarg1) {
  void * jresult ;
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  result = (operations_research::SequenceVarElement *)(arg1)->Clone();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_Copy___(void * jarg1, void * jarg2) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  operations_research::SequenceVarElement *arg2 = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  arg2 = (operations_research::SequenceVarElement *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::SequenceVarElement const & type is null", 0);
    return ;
  } 
  (arg1)->Copy((operations_research::SequenceVarElement const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_Var___(void * jarg1) {
  void * jresult ;
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  operations_research::SequenceVar *result = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  result = (operations_research::SequenceVar *)((operations_research::SequenceVarElement const *)arg1)->Var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_Store___(void * jarg1) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  (arg1)->Store();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_Restore___(void * jarg1) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  (arg1)->Restore();
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_ForwardSequence___(void * jarg1) {
  void* jresult ;
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  result = (std::vector< int > *) &((operations_research::SequenceVarElement const *)arg1)->ForwardSequence();
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_BackwardSequence___(void * jarg1) {
  void* jresult ;
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  result = (std::vector< int > *) &((operations_research::SequenceVarElement const *)arg1)->BackwardSequence();
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_Unperformed___(void * jarg1) {
  void* jresult ;
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  result = (std::vector< int > *) &((operations_research::SequenceVarElement const *)arg1)->Unperformed();
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_SetSequence___(void * jarg1,  int length2, int*  jarg2,  int length3, int*  jarg3,  int length4, int*  jarg4) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  std::vector< int > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  (arg1)->SetSequence((std::vector< int > const &)*arg2,(std::vector< int > const &)*arg3,(std::vector< int > const &)*arg4);
  {
    delete arg2; 
  }
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_SetForwardSequence___(void * jarg1,  int length2, int*  jarg2) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  (arg1)->SetForwardSequence((std::vector< int > const &)*arg2);
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_SetBackwardSequence___(void * jarg1,  int length2, int*  jarg2) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  (arg1)->SetBackwardSequence((std::vector< int > const &)*arg2);
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_SetUnperformed___(void * jarg1,  int length2, int*  jarg2) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  (arg1)->SetUnperformed((std::vector< int > const &)*arg2);
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_Bound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  bool result;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  result = (bool)((operations_research::SequenceVarElement const *)arg1)->Bound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  std::string result;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  result = ((operations_research::SequenceVarElement const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SequenceVarElement___(void * jarg1) {
  operations_research::SequenceVarElement *arg1 = (operations_research::SequenceVarElement *) 0 ;
  
  arg1 = (operations_research::SequenceVarElement *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Assignment__SWIG_0___(void * jarg1) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  result = (operations_research::Assignment *)new operations_research::Assignment(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Assignment__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (operations_research::Assignment *)new operations_research::Assignment((operations_research::Assignment const *)arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Assignment___(void * jarg1) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Clear___(void * jarg1) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  (arg1)->Clear();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Empty___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (bool)((operations_research::Assignment const *)arg1)->Empty();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Size___(void * jarg1) {
  int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (int)((operations_research::Assignment const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_NumIntVars___(void * jarg1) {
  int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (int)((operations_research::Assignment const *)arg1)->NumIntVars();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_NumIntervalVars___(void * jarg1) {
  int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (int)((operations_research::Assignment const *)arg1)->NumIntervalVars();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_NumSequenceVars___(void * jarg1) {
  int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (int)((operations_research::Assignment const *)arg1)->NumSequenceVars();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Store___(void * jarg1) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  (arg1)->Store();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Restore___(void * jarg1) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  (arg1)->Restore();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_AddObjective___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->AddObjective(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ClearObjective___(void * jarg1) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  (arg1)->ClearObjective();
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Objective___(void * jarg1) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (operations_research::IntVar *)((operations_research::Assignment const *)arg1)->Objective();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_HasObjective___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (bool)((operations_research::Assignment const *)arg1)->HasObjective();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ObjectiveMin___(void * jarg1) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->ObjectiveMin();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ObjectiveMax___(void * jarg1) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->ObjectiveMax();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ObjectiveValue___(void * jarg1) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->ObjectiveValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ObjectiveBound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (bool)((operations_research::Assignment const *)arg1)->ObjectiveBound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetObjectiveMin___(void * jarg1, long long jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetObjectiveMin(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetObjectiveMax___(void * jarg1, long long jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetObjectiveMax(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetObjectiveValue___(void * jarg1, long long jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetObjectiveValue(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetObjectiveRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetObjectiveRange(arg2,arg3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Add__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (operations_research::IntVarElement *)(arg1)->Add(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Add__SWIG_1___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->Add((std::vector< operations_research::IntVar * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_FastAdd__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (operations_research::IntVarElement *)(arg1)->FastAdd(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Min___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->Min((operations_research::IntVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Max___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->Max((operations_research::IntVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Value___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->Value((operations_research::IntVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Bound___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (bool)((operations_research::Assignment const *)arg1)->Bound((operations_research::IntVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetMin___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetMin((operations_research::IntVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetMax___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetMax((operations_research::IntVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetRange___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetRange((operations_research::IntVar const *)arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetValue((operations_research::IntVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Add__SWIG_2___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVarElement *)(arg1)->Add(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Add__SWIG_3___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  std::vector< operations_research::IntervalVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (std::vector< operations_research::IntervalVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntervalVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->Add((std::vector< operations_research::IntervalVar * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_FastAdd__SWIG_1___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVarElement *)(arg1)->FastAdd(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_StartMin___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->StartMin((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_StartMax___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->StartMax((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_StartValue___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->StartValue((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_DurationMin___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->DurationMin((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_DurationMax___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->DurationMax((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_DurationValue___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->DurationValue((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_EndMin___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->EndMin((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_EndMax___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->EndMax((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_EndValue___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->EndValue((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_PerformedMin___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->PerformedMin((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_PerformedMax___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->PerformedMax((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_PerformedValue___(void * jarg1, void * jarg2) {
  long long jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (int64_t)((operations_research::Assignment const *)arg1)->PerformedValue((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetStartMin___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetStartMin((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetStartMax___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetStartMax((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetStartRange___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetStartRange((operations_research::IntervalVar const *)arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetStartValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetStartValue((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetDurationMin___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetDurationMin((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetDurationMax___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetDurationMax((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetDurationRange___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetDurationRange((operations_research::IntervalVar const *)arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetDurationValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetDurationValue((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetEndMin___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetEndMin((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetEndMax___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetEndMax((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetEndRange___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetEndRange((operations_research::IntervalVar const *)arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetEndValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetEndValue((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetPerformedMin___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetPerformedMin((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetPerformedMax___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetPerformedMax((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetPerformedRange___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetPerformedRange((operations_research::IntervalVar const *)arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetPerformedValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetPerformedValue((operations_research::IntervalVar const *)arg2,arg3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Add__SWIG_4___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (operations_research::SequenceVarElement *)(arg1)->Add(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Add__SWIG_5___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  std::vector< operations_research::SequenceVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (std::vector< operations_research::SequenceVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->Add((std::vector< operations_research::SequenceVar * > const &)*arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_FastAdd__SWIG_2___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (operations_research::SequenceVarElement *)(arg1)->FastAdd(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ForwardSequence___(void * jarg1, void * jarg2) {
  void* jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (std::vector< int > *) &((operations_research::Assignment const *)arg1)->ForwardSequence((operations_research::SequenceVar const *)arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_BackwardSequence___(void * jarg1, void * jarg2) {
  void* jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (std::vector< int > *) &((operations_research::Assignment const *)arg1)->BackwardSequence((operations_research::SequenceVar const *)arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Unperformed___(void * jarg1, void * jarg2) {
  void* jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (std::vector< int > *) &((operations_research::Assignment const *)arg1)->Unperformed((operations_research::SequenceVar const *)arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetSequence___(void * jarg1, void * jarg2,  int length3, int*  jarg3,  int length4, int*  jarg4,  int length5, int*  jarg5) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  std::vector< int > *arg5 = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  
  arg5 = new std::vector<int>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  (arg1)->SetSequence((operations_research::SequenceVar const *)arg2,(std::vector< int > const &)*arg3,(std::vector< int > const &)*arg4,(std::vector< int > const &)*arg5);
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
  {
    delete arg5; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetForwardSequence___(void * jarg1, void * jarg2,  int length3, int*  jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->SetForwardSequence((operations_research::SequenceVar const *)arg2,(std::vector< int > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetBackwardSequence___(void * jarg1, void * jarg2,  int length3, int*  jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->SetBackwardSequence((operations_research::SequenceVar const *)arg2,(std::vector< int > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SetUnperformed___(void * jarg1, void * jarg2,  int length3, int*  jarg3) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->SetUnperformed((operations_research::SequenceVar const *)arg2,(std::vector< int > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Activate__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->Activate((operations_research::IntVar const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Deactivate__SWIG_0___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->Deactivate((operations_research::IntVar const *)arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Activated__SWIG_0___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (bool)((operations_research::Assignment const *)arg1)->Activated((operations_research::IntVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Activate__SWIG_1___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  (arg1)->Activate((operations_research::IntervalVar const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Deactivate__SWIG_1___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  (arg1)->Deactivate((operations_research::IntervalVar const *)arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Activated__SWIG_1___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (bool)((operations_research::Assignment const *)arg1)->Activated((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Activate__SWIG_2___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  (arg1)->Activate((operations_research::SequenceVar const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Deactivate__SWIG_2___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  (arg1)->Deactivate((operations_research::SequenceVar const *)arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Activated__SWIG_2___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (bool)((operations_research::Assignment const *)arg1)->Activated((operations_research::SequenceVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ActivateObjective___(void * jarg1) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  (arg1)->ActivateObjective();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_DeactivateObjective___(void * jarg1) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  (arg1)->DeactivateObjective();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ActivatedObjective___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (bool)((operations_research::Assignment const *)arg1)->ActivatedObjective();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = ((operations_research::Assignment const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_AreAllElementsBound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (bool)((operations_research::Assignment const *)arg1)->AreAllElementsBound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Contains__SWIG_0___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (bool)((operations_research::Assignment const *)arg1)->Contains((operations_research::IntVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Contains__SWIG_1___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (bool)((operations_research::Assignment const *)arg1)->Contains((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Contains__SWIG_2___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  bool result;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (bool)((operations_research::Assignment const *)arg1)->Contains((operations_research::SequenceVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_CopyIntersection___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  (arg1)->CopyIntersection((operations_research::Assignment const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_Copy___(void * jarg1, void * jarg2) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  (arg1)->Copy((operations_research::Assignment const *)arg2);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_IntVarContainer___(void * jarg1) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment::IntContainer *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (operations_research::Assignment::IntContainer *) &((operations_research::Assignment const *)arg1)->IntVarContainer();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_MutableIntVarContainer___(void * jarg1) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment::IntContainer *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (operations_research::Assignment::IntContainer *)(arg1)->MutableIntVarContainer();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_IntervalVarContainer___(void * jarg1) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment::IntervalContainer *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (operations_research::Assignment::IntervalContainer *) &((operations_research::Assignment const *)arg1)->IntervalVarContainer();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_MutableIntervalVarContainer___(void * jarg1) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment::IntervalContainer *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (operations_research::Assignment::IntervalContainer *)(arg1)->MutableIntervalVarContainer();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SequenceVarContainer___(void * jarg1) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment::SequenceContainer *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (operations_research::Assignment::SequenceContainer *) &((operations_research::Assignment const *)arg1)->SequenceVarContainer();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_MutableSequenceVarContainer___(void * jarg1) {
  void * jresult ;
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment::SequenceContainer *result = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  result = (operations_research::Assignment::SequenceContainer *)(arg1)->MutableSequenceVarContainer();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SetAssignmentFromAssignment___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  operations_research::Assignment *arg1 = (operations_research::Assignment *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  std::vector< operations_research::IntVar * > *arg4 = 0 ;
  
  arg1 = (operations_research::Assignment *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = (std::vector< operations_research::IntVar * > *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  operations_research::SetAssignmentFromAssignment(arg1,(std::vector< operations_research::IntVar * > const &)*arg2,(operations_research::Assignment const *)arg3,(std::vector< operations_research::IntVar * > const &)*arg4);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_Pack___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int arg3 ;
  operations_research::Pack *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int)jarg3; 
  result = (operations_research::Pack *)new operations_research::Pack(arg1,(std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_Pack___(void * jarg1) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddWeightedSumLessOrEqualConstantDimension__SWIG_0___(void * jarg1,  int length2, int64_t*  jarg2,  int length3, int64_t*  jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->AddWeightedSumLessOrEqualConstantDimension((std::vector< int64_t > const &)*arg2,(std::vector< int64_t > const &)*arg3);
  {
    delete arg2; 
  }
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddWeightedSumLessOrEqualConstantDimension__SWIG_1___(void * jarg1,  void *  jarg2,  int length3, int64_t*  jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  operations_research::Solver::IndexEvaluator1 arg2 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  
  arg2 = [jarg2](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg2)(t);
  };
  
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->AddWeightedSumLessOrEqualConstantDimension(arg2,(std::vector< int64_t > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddWeightedSumLessOrEqualConstantDimension__SWIG_2___(void * jarg1,  void *  jarg2,  int length3, int64_t*  jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  operations_research::Solver::IndexEvaluator2 arg2 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  
  arg2 = [jarg2](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg2)(t, u);
  };
  
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->AddWeightedSumLessOrEqualConstantDimension(arg2,(std::vector< int64_t > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddWeightedSumEqualVarDimension__SWIG_0___(void * jarg1,  int length2, int64_t*  jarg2, void * jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->AddWeightedSumEqualVarDimension((std::vector< int64_t > const &)*arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddWeightedSumEqualVarDimension__SWIG_1___(void * jarg1,  void *  jarg2, void * jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  operations_research::Solver::IndexEvaluator2 arg2 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  
  arg2 = [jarg2](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg2)(t, u);
  };
  
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->AddWeightedSumEqualVarDimension(arg2,(std::vector< operations_research::IntVar * > const &)*arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddSumVariableWeightsLessOrEqualConstantDimension___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->AddSumVariableWeightsLessOrEqualConstantDimension((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddWeightedSumOfAssignedDimension___(void * jarg1,  int length2, int64_t*  jarg2, void * jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (operations_research::IntVar *)jarg3; 
  (arg1)->AddWeightedSumOfAssignedDimension((std::vector< int64_t > const &)*arg2,arg3);
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddCountUsedBinDimension___(void * jarg1, void * jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->AddCountUsedBinDimension(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AddCountAssignedItemsDimension___(void * jarg1, void * jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->AddCountAssignedItemsDimension(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_Post___(void * jarg1) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  (arg1)->Post();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_ClearAll___(void * jarg1) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  (arg1)->ClearAll();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_PropagateDelayed___(void * jarg1) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  (arg1)->PropagateDelayed();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_InitialPropagateWrapper___(void * jarg1) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  (arg1)->InitialPropagate();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_Propagate___(void * jarg1) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  (arg1)->Propagate();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_OneDomain___(void * jarg1, int jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->OneDomain(arg2);
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  std::string result;
  
  arg1 = (operations_research::Pack *)jarg1; 
  result = ((operations_research::Pack const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_IsUndecided___(void * jarg1, int jarg2, int jarg3) {
  unsigned int jresult ;
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  int arg3 ;
  bool result;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)((operations_research::Pack const *)arg1)->IsUndecided(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_SetImpossible___(void * jarg1, int jarg2, int jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->SetImpossible(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_Assign___(void * jarg1, int jarg2, int jarg3) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->Assign(arg2,arg3);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_IsAssignedStatusKnown___(void * jarg1, int jarg2) {
  unsigned int jresult ;
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  bool result;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  result = (bool)((operations_research::Pack const *)arg1)->IsAssignedStatusKnown(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_IsPossible___(void * jarg1, int jarg2, int jarg3) {
  unsigned int jresult ;
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  int arg3 ;
  bool result;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)((operations_research::Pack const *)arg1)->IsPossible(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AssignVar___(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  int arg3 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::IntVar *)((operations_research::Pack const *)arg1)->AssignVar(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_SetAssigned___(void * jarg1, int jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->SetAssigned(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_SetUnassigned___(void * jarg1, int jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->SetUnassigned(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_RemoveAllPossibleFromBin___(void * jarg1, int jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->RemoveAllPossibleFromBin(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AssignAllPossibleToBin___(void * jarg1, int jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->AssignAllPossibleToBin(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AssignFirstPossibleToBin___(void * jarg1, int jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->AssignFirstPossibleToBin(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_AssignAllRemainingItems___(void * jarg1) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  (arg1)->AssignAllRemainingItems();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_UnassignAllRemainingItems___(void * jarg1) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  (arg1)->UnassignAllRemainingItems();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_Accept___(void * jarg1, void * jarg2) {
  operations_research::Pack *arg1 = (operations_research::Pack *) 0 ;
  operations_research::ModelVisitor *arg2 = (operations_research::ModelVisitor *) (operations_research::ModelVisitor *)0 ;
  
  arg1 = (operations_research::Pack *)jarg1; 
  arg2 = (operations_research::ModelVisitor *)jarg2; 
  ((operations_research::Pack const *)arg1)->Accept(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_DisjunctiveConstraint___(void * jarg1) {
  operations_research::DisjunctiveConstraint *arg1 = (operations_research::DisjunctiveConstraint *) 0 ;
  
  arg1 = (operations_research::DisjunctiveConstraint *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DisjunctiveConstraint_SequenceVar___(void * jarg1) {
  void * jresult ;
  operations_research::DisjunctiveConstraint *arg1 = (operations_research::DisjunctiveConstraint *) 0 ;
  operations_research::SequenceVar *result = 0 ;
  
  arg1 = (operations_research::DisjunctiveConstraint *)jarg1; 
  result = (operations_research::SequenceVar *)(arg1)->MakeSequenceVar();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DisjunctiveConstraint_SetTransitionTime___(void * jarg1,  void *  jarg2) {
  operations_research::DisjunctiveConstraint *arg1 = (operations_research::DisjunctiveConstraint *) 0 ;
  operations_research::Solver::IndexEvaluator2 arg2 ;
  
  arg1 = (operations_research::DisjunctiveConstraint *)jarg1; 
  
  arg2 = [jarg2](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg2)(t, u);
  };
  
  (arg1)->SetTransitionTime(arg2);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DisjunctiveConstraint_TransitionTime___(void * jarg1, int jarg2, int jarg3) {
  long long jresult ;
  operations_research::DisjunctiveConstraint *arg1 = (operations_research::DisjunctiveConstraint *) 0 ;
  int arg2 ;
  int arg3 ;
  int64_t result;
  
  arg1 = (operations_research::DisjunctiveConstraint *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  result = (int64_t)(arg1)->TransitionTime(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SolutionPool___(void * jarg1) {
  operations_research::SolutionPool *arg1 = (operations_research::SolutionPool *) 0 ;
  
  arg1 = (operations_research::SolutionPool *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionPool_Initialize___(void * jarg1, void * jarg2) {
  operations_research::SolutionPool *arg1 = (operations_research::SolutionPool *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  
  arg1 = (operations_research::SolutionPool *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  (arg1)->Initialize(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionPool_RegisterNewSolution___(void * jarg1, void * jarg2) {
  operations_research::SolutionPool *arg1 = (operations_research::SolutionPool *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  
  arg1 = (operations_research::SolutionPool *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  (arg1)->RegisterNewSolution(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionPool_GetNextSolution___(void * jarg1, void * jarg2) {
  operations_research::SolutionPool *arg1 = (operations_research::SolutionPool *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  
  arg1 = (operations_research::SolutionPool *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  (arg1)->GetNextSolution(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionPool_SyncNeeded___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::SolutionPool *arg1 = (operations_research::SolutionPool *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  bool result;
  
  arg1 = (operations_research::SolutionPool *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (bool)(arg1)->SyncNeeded(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_BaseIntExpr___(void * jarg1) {
  operations_research::BaseIntExpr *arg1 = (operations_research::BaseIntExpr *) 0 ;
  
  arg1 = (operations_research::BaseIntExpr *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseIntExpr_Var___(void * jarg1) {
  void * jresult ;
  operations_research::BaseIntExpr *arg1 = (operations_research::BaseIntExpr *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::BaseIntExpr *)jarg1; 
  result = (operations_research::IntVar *)(arg1)->Var();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseIntExpr_CastToVar___(void * jarg1) {
  void * jresult ;
  operations_research::BaseIntExpr *arg1 = (operations_research::BaseIntExpr *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::BaseIntExpr *)jarg1; 
  result = (operations_research::IntVar *)(arg1)->CastToVar();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_UNSPECIFIED_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::UNSPECIFIED;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DOMAIN_INT_VAR_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::DOMAIN_INT_VAR;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BOOLEAN_VAR_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::BOOLEAN_VAR;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_CONST_VAR_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::CONST_VAR;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_VAR_ADD_CST_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::VAR_ADD_CST;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_VAR_TIMES_CST_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::VAR_TIMES_CST;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_CST_SUB_VAR_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::CST_SUB_VAR;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OPP_VAR_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::OPP_VAR;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_TRACE_VAR_get___() {
  int jresult ;
  operations_research::VarTypes result;
  
  result = (operations_research::VarTypes)operations_research::TRACE_VAR;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchOperator___() {
  void * jresult ;
  operations_research::LocalSearchOperator *result = 0 ;
  
  result = (operations_research::LocalSearchOperator *)new SwigDirector_LocalSearchOperator();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_LocalSearchOperator___(void * jarg1) {
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_MakeNextNeighbor___(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  result = (bool)(arg1)->MakeNextNeighbor(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_Start___(void * jarg1, void * jarg2) {
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  (arg1)->Start((operations_research::Assignment const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_Reset___(void * jarg1) {
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  (arg1)->Reset();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_ResetSwigExplicitLocalSearchOperator___(void * jarg1) {
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  (arg1)->operations_research::LocalSearchOperator::Reset();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_HasFragments___(void * jarg1) {
  unsigned int jresult ;
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  result = (bool)((operations_research::LocalSearchOperator const *)arg1)->HasFragments();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_HasFragmentsSwigExplicitLocalSearchOperator___(void * jarg1) {
  unsigned int jresult ;
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  result = (bool)((operations_research::LocalSearchOperator const *)arg1)->operations_research::LocalSearchOperator::HasFragments();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_HoldsDelta___(void * jarg1) {
  unsigned int jresult ;
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  result = (bool)((operations_research::LocalSearchOperator const *)arg1)->HoldsDelta();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_HoldsDeltaSwigExplicitLocalSearchOperator___(void * jarg1) {
  unsigned int jresult ;
  operations_research::LocalSearchOperator *arg1 = (operations_research::LocalSearchOperator *) 0 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchOperator *)jarg1; 
  result = (bool)((operations_research::LocalSearchOperator const *)arg1)->operations_research::LocalSearchOperator::HoldsDelta();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_director_connect___(void *objarg, SwigDirector_LocalSearchOperator::SWIG_Callback0_t callback0, SwigDirector_LocalSearchOperator::SWIG_Callback1_t callback1, SwigDirector_LocalSearchOperator::SWIG_Callback2_t callback2, SwigDirector_LocalSearchOperator::SWIG_Callback3_t callback3, SwigDirector_LocalSearchOperator::SWIG_Callback4_t callback4, SwigDirector_LocalSearchOperator::SWIG_Callback5_t callback5) {
  operations_research::LocalSearchOperator *obj = (operations_research::LocalSearchOperator *)objarg;
  SwigDirector_LocalSearchOperator *director = static_cast<SwigDirector_LocalSearchOperator *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVarLocalSearchOperatorTemplate___(void * jarg1) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_HoldsDelta___(void * jarg1) {
  unsigned int jresult ;
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  bool result;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  result = (bool)((operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > const *)arg1)->HoldsDelta();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_IsIncremental___(void * jarg1) {
  unsigned int jresult ;
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  bool result;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  result = (bool)((operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > const *)arg1)->IsIncremental();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_Size___(void * jarg1) {
  int jresult ;
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  int result;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  result = (int)((operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_Value___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  long *result = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (long *) &((operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > const *)arg1)->Value(arg2);
  jresult = *result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_Var___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)((operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > const *)arg1)->Var(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_OldValue___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  long *result = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (long *) &((operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > const *)arg1)->OldValue(arg2);
  jresult = *result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_SetValue___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  long *arg3 = 0 ;
  long temp3 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  temp3 = (long)jarg3; 
  arg3 = &temp3; 
  (arg1)->SetValue(arg2,(long const &)*arg3);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_Activated___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (bool)((operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > const *)arg1)->Activated(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_Activate___(void * jarg1, long long jarg2) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->Activate(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_Deactivate___(void * jarg1, long long jarg2) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->Deactivate(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_AddVars___(void * jarg1, void * jarg2) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->AddVars((std::vector< operations_research::IntVar * > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_OnStart___(void * jarg1) {
  operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *) 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1; 
  (arg1)->OnStart();
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarLocalSearchOperator__SWIG_0___() {
  void * jresult ;
  operations_research::IntVarLocalSearchOperator *result = 0 ;
  
  result = (operations_research::IntVarLocalSearchOperator *)new SwigDirector_IntVarLocalSearchOperator();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarLocalSearchOperator__SWIG_1___(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  bool arg2 ;
  operations_research::IntVarLocalSearchOperator *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  result = (operations_research::IntVarLocalSearchOperator *)new SwigDirector_IntVarLocalSearchOperator((std::vector< operations_research::IntVar * > const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarLocalSearchOperator__SWIG_2___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  operations_research::IntVarLocalSearchOperator *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::IntVarLocalSearchOperator *)new SwigDirector_IntVarLocalSearchOperator((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVarLocalSearchOperator___(void * jarg1) {
  operations_research::IntVarLocalSearchOperator *arg1 = (operations_research::IntVarLocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::IntVarLocalSearchOperator *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperator_MakeOneNeighbor___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntVarLocalSearchOperator *arg1 = (operations_research::IntVarLocalSearchOperator *) 0 ;
  SwigDirector_IntVarLocalSearchOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::IntVarLocalSearchOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_IntVarLocalSearchOperator *>(arg1);
  result = (bool)(darg)->MakeOneNeighbor();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperator_MakeOneNeighborSwigExplicitIntVarLocalSearchOperator___(void * jarg1) {
  unsigned int jresult ;
  operations_research::IntVarLocalSearchOperator *arg1 = (operations_research::IntVarLocalSearchOperator *) 0 ;
  SwigDirector_IntVarLocalSearchOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::IntVarLocalSearchOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_IntVarLocalSearchOperator *>(arg1);
  result = (bool)(darg)->MakeOneNeighborSwigPublic();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperator_director_connect___(void *objarg, SwigDirector_IntVarLocalSearchOperator::SWIG_Callback0_t callback0, SwigDirector_IntVarLocalSearchOperator::SWIG_Callback1_t callback1, SwigDirector_IntVarLocalSearchOperator::SWIG_Callback2_t callback2, SwigDirector_IntVarLocalSearchOperator::SWIG_Callback3_t callback3, SwigDirector_IntVarLocalSearchOperator::SWIG_Callback4_t callback4, SwigDirector_IntVarLocalSearchOperator::SWIG_Callback5_t callback5, SwigDirector_IntVarLocalSearchOperator::SWIG_Callback6_t callback6) {
  operations_research::IntVarLocalSearchOperator *obj = (operations_research::IntVarLocalSearchOperator *)objarg;
  SwigDirector_IntVarLocalSearchOperator *director = static_cast<SwigDirector_IntVarLocalSearchOperator *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SequenceVarLocalSearchOperatorTemplate___(void * jarg1) {
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_HoldsDelta___(void * jarg1) {
  unsigned int jresult ;
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  bool result;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  result = (bool)((operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > const *)arg1)->HoldsDelta();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_IsIncremental___(void * jarg1) {
  unsigned int jresult ;
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  bool result;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  result = (bool)((operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > const *)arg1)->IsIncremental();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_Size___(void * jarg1) {
  int jresult ;
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  int result;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  result = (int)((operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_Value___(void * jarg1, long long jarg2) {
  void* jresult ;
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (std::vector< int > *) &((operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > const *)arg1)->Value(arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_Var___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  operations_research::SequenceVar *result = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::SequenceVar *)((operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > const *)arg1)->Var(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_OldValue___(void * jarg1, long long jarg2) {
  void* jresult ;
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (std::vector< int > *) &((operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > const *)arg1)->OldValue(arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_SetValue___(void * jarg1, long long jarg2,  int length3, int*  jarg3) {
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->SetValue(arg2,(std::vector< int > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_Activated___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (bool)((operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > const *)arg1)->Activated(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_Activate___(void * jarg1, long long jarg2) {
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->Activate(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_Deactivate___(void * jarg1, long long jarg2) {
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->Deactivate(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_AddVars___(void * jarg1, void * jarg2) {
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  std::vector< operations_research::SequenceVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  arg2 = (std::vector< operations_research::SequenceVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->AddVars((std::vector< operations_research::SequenceVar * > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_OnStart___(void * jarg1) {
  operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *) 0 ;
  
  arg1 = (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1; 
  (arg1)->OnStart();
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SequenceVarLocalSearchOperator__SWIG_0___() {
  void * jresult ;
  operations_research::SequenceVarLocalSearchOperator *result = 0 ;
  
  result = (operations_research::SequenceVarLocalSearchOperator *)new SwigDirector_SequenceVarLocalSearchOperator();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SequenceVarLocalSearchOperator__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::SequenceVar * > *arg1 = 0 ;
  operations_research::SequenceVarLocalSearchOperator *result = 0 ;
  
  arg1 = (std::vector< operations_research::SequenceVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::SequenceVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::SequenceVarLocalSearchOperator *)new SwigDirector_SequenceVarLocalSearchOperator((std::vector< operations_research::SequenceVar * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SequenceVarLocalSearchOperator___(void * jarg1) {
  operations_research::SequenceVarLocalSearchOperator *arg1 = (operations_research::SequenceVarLocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::SequenceVarLocalSearchOperator *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperator_Sequence___(void * jarg1, long long jarg2) {
  void* jresult ;
  operations_research::SequenceVarLocalSearchOperator *arg1 = (operations_research::SequenceVarLocalSearchOperator *) 0 ;
  int64_t arg2 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::SequenceVarLocalSearchOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (std::vector< int > *) &((operations_research::SequenceVarLocalSearchOperator const *)arg1)->Sequence(arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperator_OldSequence___(void * jarg1, long long jarg2) {
  void* jresult ;
  operations_research::SequenceVarLocalSearchOperator *arg1 = (operations_research::SequenceVarLocalSearchOperator *) 0 ;
  int64_t arg2 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::SequenceVarLocalSearchOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (std::vector< int > *) &((operations_research::SequenceVarLocalSearchOperator const *)arg1)->OldSequence(arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperator_director_connect___(void *objarg, SwigDirector_SequenceVarLocalSearchOperator::SWIG_Callback0_t callback0, SwigDirector_SequenceVarLocalSearchOperator::SWIG_Callback1_t callback1, SwigDirector_SequenceVarLocalSearchOperator::SWIG_Callback2_t callback2, SwigDirector_SequenceVarLocalSearchOperator::SWIG_Callback3_t callback3, SwigDirector_SequenceVarLocalSearchOperator::SWIG_Callback4_t callback4, SwigDirector_SequenceVarLocalSearchOperator::SWIG_Callback5_t callback5, SwigDirector_SequenceVarLocalSearchOperator::SWIG_Callback6_t callback6) {
  operations_research::SequenceVarLocalSearchOperator *obj = (operations_research::SequenceVarLocalSearchOperator *)objarg;
  SwigDirector_SequenceVarLocalSearchOperator *director = static_cast<SwigDirector_SequenceVarLocalSearchOperator *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_BaseLns___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  operations_research::BaseLns *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::BaseLns *)new SwigDirector_BaseLns((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_BaseLns___(void * jarg1) {
  operations_research::BaseLns *arg1 = (operations_research::BaseLns *) 0 ;
  
  arg1 = (operations_research::BaseLns *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_InitFragments___(void * jarg1) {
  operations_research::BaseLns *arg1 = (operations_research::BaseLns *) 0 ;
  
  arg1 = (operations_research::BaseLns *)jarg1; 
  (arg1)->InitFragments();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_InitFragmentsSwigExplicitBaseLns___(void * jarg1) {
  operations_research::BaseLns *arg1 = (operations_research::BaseLns *) 0 ;
  
  arg1 = (operations_research::BaseLns *)jarg1; 
  (arg1)->operations_research::BaseLns::InitFragments();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_NextFragment___(void * jarg1) {
  unsigned int jresult ;
  operations_research::BaseLns *arg1 = (operations_research::BaseLns *) 0 ;
  bool result;
  
  arg1 = (operations_research::BaseLns *)jarg1; 
  result = (bool)(arg1)->NextFragment();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_AppendToFragment___(void * jarg1, int jarg2) {
  operations_research::BaseLns *arg1 = (operations_research::BaseLns *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::BaseLns *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->AppendToFragment(arg2);
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_FragmentSize___(void * jarg1) {
  int jresult ;
  operations_research::BaseLns *arg1 = (operations_research::BaseLns *) 0 ;
  int result;
  
  arg1 = (operations_research::BaseLns *)jarg1; 
  result = (int)((operations_research::BaseLns const *)arg1)->FragmentSize();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_HasFragments___(void * jarg1) {
  unsigned int jresult ;
  operations_research::BaseLns *arg1 = (operations_research::BaseLns *) 0 ;
  bool result;
  
  arg1 = (operations_research::BaseLns *)jarg1; 
  result = (bool)((operations_research::BaseLns const *)arg1)->HasFragments();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_HasFragmentsSwigExplicitBaseLns___(void * jarg1) {
  unsigned int jresult ;
  operations_research::BaseLns *arg1 = (operations_research::BaseLns *) 0 ;
  bool result;
  
  arg1 = (operations_research::BaseLns *)jarg1; 
  result = (bool)((operations_research::BaseLns const *)arg1)->operations_research::BaseLns::HasFragments();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_director_connect___(void *objarg, SwigDirector_BaseLns::SWIG_Callback0_t callback0, SwigDirector_BaseLns::SWIG_Callback1_t callback1, SwigDirector_BaseLns::SWIG_Callback2_t callback2, SwigDirector_BaseLns::SWIG_Callback3_t callback3, SwigDirector_BaseLns::SWIG_Callback4_t callback4, SwigDirector_BaseLns::SWIG_Callback5_t callback5, SwigDirector_BaseLns::SWIG_Callback6_t callback6) {
  operations_research::BaseLns *obj = (operations_research::BaseLns *)objarg;
  SwigDirector_BaseLns *director = static_cast<SwigDirector_BaseLns *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_ChangeValue___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  operations_research::ChangeValue *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::ChangeValue *)new SwigDirector_ChangeValue((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_ChangeValue___(void * jarg1) {
  operations_research::ChangeValue *arg1 = (operations_research::ChangeValue *) 0 ;
  
  arg1 = (operations_research::ChangeValue *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ChangeValue_ModifyValue___(void * jarg1, long long jarg2, long long jarg3) {
  long long jresult ;
  operations_research::ChangeValue *arg1 = (operations_research::ChangeValue *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t result;
  
  arg1 = (operations_research::ChangeValue *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (int64_t)(arg1)->ModifyValue(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ChangeValue_MakeOneNeighbor___(void * jarg1) {
  unsigned int jresult ;
  operations_research::ChangeValue *arg1 = (operations_research::ChangeValue *) 0 ;
  SwigDirector_ChangeValue *darg = 0;
  bool result;
  
  arg1 = (operations_research::ChangeValue *)jarg1; 
  darg = dynamic_cast<SwigDirector_ChangeValue *>(arg1);
  result = (bool)(darg)->MakeOneNeighbor();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ChangeValue_MakeOneNeighborSwigExplicitChangeValue___(void * jarg1) {
  unsigned int jresult ;
  operations_research::ChangeValue *arg1 = (operations_research::ChangeValue *) 0 ;
  SwigDirector_ChangeValue *darg = 0;
  bool result;
  
  arg1 = (operations_research::ChangeValue *)jarg1; 
  darg = dynamic_cast<SwigDirector_ChangeValue *>(arg1);
  result = (bool)(darg)->MakeOneNeighborSwigPublic();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ChangeValue_director_connect___(void *objarg, SwigDirector_ChangeValue::SWIG_Callback0_t callback0, SwigDirector_ChangeValue::SWIG_Callback1_t callback1, SwigDirector_ChangeValue::SWIG_Callback2_t callback2, SwigDirector_ChangeValue::SWIG_Callback3_t callback3, SwigDirector_ChangeValue::SWIG_Callback4_t callback4, SwigDirector_ChangeValue::SWIG_Callback5_t callback5, SwigDirector_ChangeValue::SWIG_Callback6_t callback6, SwigDirector_ChangeValue::SWIG_Callback7_t callback7) {
  operations_research::ChangeValue *obj = (operations_research::ChangeValue *)objarg;
  SwigDirector_ChangeValue *director = static_cast<SwigDirector_ChangeValue *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_PathOperator___(void * jarg1) {
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_MakeNeighbor___(void * jarg1) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  result = (bool)(arg1)->MakeNeighbor();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_Reset___(void * jarg1) {
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  (arg1)->Reset();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_ResetSwigExplicitPathOperator___(void * jarg1) {
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  (arg1)->operations_research::PathOperator::Reset();
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_Prev___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)((operations_research::PathOperator const *)arg1)->Prev(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_MakeOneNeighbor___(void * jarg1) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)(darg)->MakeOneNeighbor();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_MakeOneNeighborSwigExplicitPathOperator___(void * jarg1) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)(darg)->MakeOneNeighborSwigPublic();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_OnNodeInitialization___(void * jarg1) {
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  SwigDirector_PathOperator *darg = 0;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  (darg)->OnNodeInitialization();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_OnNodeInitializationSwigExplicitPathOperator___(void * jarg1) {
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  SwigDirector_PathOperator *darg = 0;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  (darg)->OnNodeInitializationSwigPublic();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_RestartAtPathStartOnSynchronize___(void * jarg1) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)(darg)->RestartAtPathStartOnSynchronize();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_RestartAtPathStartOnSynchronizeSwigExplicitPathOperator___(void * jarg1) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)(darg)->RestartAtPathStartOnSynchronizeSwigPublic();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_OnSamePathAsPreviousBase___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int64_t arg2 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)(darg)->OnSamePathAsPreviousBase(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_OnSamePathAsPreviousBaseSwigExplicitPathOperator___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int64_t arg2 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)(darg)->OnSamePathAsPreviousBaseSwigPublic(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_GetBaseNodeRestartPosition___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int arg2 ;
  SwigDirector_PathOperator *darg = 0;
  int64_t result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int)jarg2; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (int64_t)(darg)->GetBaseNodeRestartPosition(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_GetBaseNodeRestartPositionSwigExplicitPathOperator___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int arg2 ;
  SwigDirector_PathOperator *darg = 0;
  int64_t result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int)jarg2; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (int64_t)(darg)->GetBaseNodeRestartPositionSwigPublic(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_SetNextBaseToIncrement___(void * jarg1, long long jarg2) {
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int64_t arg2 ;
  SwigDirector_PathOperator *darg = 0;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  (darg)->SetNextBaseToIncrement(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_SetNextBaseToIncrementSwigExplicitPathOperator___(void * jarg1, long long jarg2) {
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int64_t arg2 ;
  SwigDirector_PathOperator *darg = 0;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  (darg)->SetNextBaseToIncrementSwigPublic(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_ConsiderAlternatives___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int64_t arg2 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)((SwigDirector_PathOperator const *)darg)->ConsiderAlternatives(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_ConsiderAlternativesSwigExplicitPathOperator___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  int64_t arg2 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  arg2 = (int64_t)jarg2; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)((SwigDirector_PathOperator const *)darg)->ConsiderAlternativesSwigPublic(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_InitPosition___(void * jarg1) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)((SwigDirector_PathOperator const *)darg)->InitPosition();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_InitPositionSwigExplicitPathOperator___(void * jarg1) {
  unsigned int jresult ;
  operations_research::PathOperator *arg1 = (operations_research::PathOperator *) 0 ;
  SwigDirector_PathOperator *darg = 0;
  bool result;
  
  arg1 = (operations_research::PathOperator *)jarg1; 
  darg = dynamic_cast<SwigDirector_PathOperator *>(arg1);
  result = (bool)((SwigDirector_PathOperator const *)darg)->InitPositionSwigPublic();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_director_connect___(void *objarg, SwigDirector_PathOperator::SWIG_Callback0_t callback0, SwigDirector_PathOperator::SWIG_Callback1_t callback1, SwigDirector_PathOperator::SWIG_Callback2_t callback2, SwigDirector_PathOperator::SWIG_Callback3_t callback3, SwigDirector_PathOperator::SWIG_Callback4_t callback4, SwigDirector_PathOperator::SWIG_Callback5_t callback5, SwigDirector_PathOperator::SWIG_Callback6_t callback6, SwigDirector_PathOperator::SWIG_Callback7_t callback7, SwigDirector_PathOperator::SWIG_Callback8_t callback8, SwigDirector_PathOperator::SWIG_Callback9_t callback9, SwigDirector_PathOperator::SWIG_Callback10_t callback10, SwigDirector_PathOperator::SWIG_Callback11_t callback11, SwigDirector_PathOperator::SWIG_Callback12_t callback12, SwigDirector_PathOperator::SWIG_Callback13_t callback13, SwigDirector_PathOperator::SWIG_Callback14_t callback14) {
  operations_research::PathOperator *obj = (operations_research::PathOperator *)objarg;
  SwigDirector_PathOperator *director = static_cast<SwigDirector_PathOperator *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_Relax___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  (arg1)->Relax((operations_research::Assignment const *)arg2,(operations_research::Assignment const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_RelaxSwigExplicitLocalSearchFilter___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  (arg1)->operations_research::LocalSearchFilter::Relax((operations_research::Assignment const *)arg2,(operations_research::Assignment const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_Commit___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  (arg1)->Commit((operations_research::Assignment const *)arg2,(operations_research::Assignment const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_CommitSwigExplicitLocalSearchFilter___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  (arg1)->operations_research::LocalSearchFilter::Commit((operations_research::Assignment const *)arg2,(operations_research::Assignment const *)arg3);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_Accept___(void * jarg1, void * jarg2, void * jarg3, long long jarg4, long long jarg5) {
  unsigned int jresult ;
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  int64_t arg4 ;
  int64_t arg5 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  result = (bool)(arg1)->Accept((operations_research::Assignment const *)arg2,(operations_research::Assignment const *)arg3,arg4,arg5);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_IsIncremental___(void * jarg1) {
  unsigned int jresult ;
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  result = (bool)((operations_research::LocalSearchFilter const *)arg1)->IsIncremental();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_IsIncrementalSwigExplicitLocalSearchFilter___(void * jarg1) {
  unsigned int jresult ;
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  result = (bool)((operations_research::LocalSearchFilter const *)arg1)->operations_research::LocalSearchFilter::IsIncremental();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_Synchronize___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  (arg1)->Synchronize((operations_research::Assignment const *)arg2,(operations_research::Assignment const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_Revert___(void * jarg1) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  (arg1)->Revert();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_RevertSwigExplicitLocalSearchFilter___(void * jarg1) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  (arg1)->operations_research::LocalSearchFilter::Revert();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_Reset___(void * jarg1) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  (arg1)->Reset();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_ResetSwigExplicitLocalSearchFilter___(void * jarg1) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  (arg1)->operations_research::LocalSearchFilter::Reset();
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_GetSynchronizedObjectiveValue___(void * jarg1) {
  long long jresult ;
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  result = (int64_t)((operations_research::LocalSearchFilter const *)arg1)->GetSynchronizedObjectiveValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_GetSynchronizedObjectiveValueSwigExplicitLocalSearchFilter___(void * jarg1) {
  long long jresult ;
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  result = (int64_t)((operations_research::LocalSearchFilter const *)arg1)->operations_research::LocalSearchFilter::GetSynchronizedObjectiveValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_GetAcceptedObjectiveValue___(void * jarg1) {
  long long jresult ;
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  result = (int64_t)((operations_research::LocalSearchFilter const *)arg1)->GetAcceptedObjectiveValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_GetAcceptedObjectiveValueSwigExplicitLocalSearchFilter___(void * jarg1) {
  long long jresult ;
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  result = (int64_t)((operations_research::LocalSearchFilter const *)arg1)->operations_research::LocalSearchFilter::GetAcceptedObjectiveValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchFilter___() {
  void * jresult ;
  operations_research::LocalSearchFilter *result = 0 ;
  
  result = (operations_research::LocalSearchFilter *)new SwigDirector_LocalSearchFilter();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_LocalSearchFilter___(void * jarg1) {
  operations_research::LocalSearchFilter *arg1 = (operations_research::LocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilter *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_director_connect___(void *objarg, SwigDirector_LocalSearchFilter::SWIG_Callback0_t callback0, SwigDirector_LocalSearchFilter::SWIG_Callback1_t callback1, SwigDirector_LocalSearchFilter::SWIG_Callback2_t callback2, SwigDirector_LocalSearchFilter::SWIG_Callback3_t callback3, SwigDirector_LocalSearchFilter::SWIG_Callback4_t callback4, SwigDirector_LocalSearchFilter::SWIG_Callback5_t callback5, SwigDirector_LocalSearchFilter::SWIG_Callback6_t callback6, SwigDirector_LocalSearchFilter::SWIG_Callback7_t callback7, SwigDirector_LocalSearchFilter::SWIG_Callback8_t callback8, SwigDirector_LocalSearchFilter::SWIG_Callback9_t callback9) {
  operations_research::LocalSearchFilter *obj = (operations_research::LocalSearchFilter *)objarg;
  SwigDirector_LocalSearchFilter *director = static_cast<SwigDirector_LocalSearchFilter *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9);
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_kAccept_get___() {
  int jresult ;
  operations_research::LocalSearchFilterManager::FilterEventType result;
  
  result = (operations_research::LocalSearchFilterManager::FilterEventType)operations_research::LocalSearchFilterManager::kAccept;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_kRelax_get___() {
  int jresult ;
  operations_research::LocalSearchFilterManager::FilterEventType result;
  
  result = (operations_research::LocalSearchFilterManager::FilterEventType)operations_research::LocalSearchFilterManager::kRelax;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_FilterEvent_filter_set___(void * jarg1, void * jarg2) {
  operations_research::LocalSearchFilterManager::FilterEvent *arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *) 0 ;
  operations_research::LocalSearchFilter *arg2 = (operations_research::LocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *)jarg1; 
  arg2 = (operations_research::LocalSearchFilter *)jarg2; 
  if (arg1) (arg1)->filter = arg2;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_FilterEvent_filter_get___(void * jarg1) {
  void * jresult ;
  operations_research::LocalSearchFilterManager::FilterEvent *arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *) 0 ;
  operations_research::LocalSearchFilter *result = 0 ;
  
  arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *)jarg1; 
  result = (operations_research::LocalSearchFilter *) ((arg1)->filter);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_FilterEvent_event_type_set___(void * jarg1, int jarg2) {
  operations_research::LocalSearchFilterManager::FilterEvent *arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *) 0 ;
  operations_research::LocalSearchFilterManager::FilterEventType arg2 ;
  
  arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *)jarg1; 
  arg2 = (operations_research::LocalSearchFilterManager::FilterEventType)jarg2; 
  if (arg1) (arg1)->event_type = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_FilterEvent_event_type_get___(void * jarg1) {
  int jresult ;
  operations_research::LocalSearchFilterManager::FilterEvent *arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *) 0 ;
  operations_research::LocalSearchFilterManager::FilterEventType result;
  
  arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *)jarg1; 
  result = (operations_research::LocalSearchFilterManager::FilterEventType) ((arg1)->event_type);
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchFilterManager_FilterEvent___() {
  void * jresult ;
  operations_research::LocalSearchFilterManager::FilterEvent *result = 0 ;
  
  result = (operations_research::LocalSearchFilterManager::FilterEvent *)new operations_research::LocalSearchFilterManager::FilterEvent();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_LocalSearchFilterManager_FilterEvent___(void * jarg1) {
  operations_research::LocalSearchFilterManager::FilterEvent *arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilterManager::FilterEvent *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::LocalSearchFilterManager *arg1 = (operations_research::LocalSearchFilterManager *) 0 ;
  std::string result;
  
  arg1 = (operations_research::LocalSearchFilterManager *)jarg1; 
  result = ((operations_research::LocalSearchFilterManager const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_ToStringSwigExplicitLocalSearchFilterManager___(void * jarg1) {
  char * jresult ;
  operations_research::LocalSearchFilterManager *arg1 = (operations_research::LocalSearchFilterManager *) 0 ;
  std::string result;
  
  arg1 = (operations_research::LocalSearchFilterManager *)jarg1; 
  result = ((operations_research::LocalSearchFilterManager const *)arg1)->operations_research::LocalSearchFilterManager::DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchFilterManager__SWIG_0___(void * jarg1) {
  void * jresult ;
  SwigValueWrapper< std::vector< operations_research::LocalSearchFilterManager::FilterEvent > > arg1 ;
  std::vector< operations_research::LocalSearchFilterManager::FilterEvent > *argp1 ;
  operations_research::LocalSearchFilterManager *result = 0 ;
  
  argp1 = (std::vector< operations_research::LocalSearchFilterManager::FilterEvent > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::LocalSearchFilterManager::FilterEvent >", 0);
    return 0;
  }
  arg1 = *argp1; 
  result = (operations_research::LocalSearchFilterManager *)new SwigDirector_LocalSearchFilterManager(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_LocalSearchFilterManager__SWIG_1___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::LocalSearchFilter * > arg1 ;
  std::vector< operations_research::LocalSearchFilter * > *argp1 ;
  operations_research::LocalSearchFilterManager *result = 0 ;
  
  argp1 = (std::vector< operations_research::LocalSearchFilter * > *)jarg1; 
  if (!argp1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::LocalSearchFilter * >", 0);
    return 0;
  }
  arg1 = *argp1; 
  result = (operations_research::LocalSearchFilterManager *)new SwigDirector_LocalSearchFilterManager(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_Revert___(void * jarg1) {
  operations_research::LocalSearchFilterManager *arg1 = (operations_research::LocalSearchFilterManager *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilterManager *)jarg1; 
  (arg1)->Revert();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_Accept___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, long long jarg5, long long jarg6) {
  unsigned int jresult ;
  operations_research::LocalSearchFilterManager *arg1 = (operations_research::LocalSearchFilterManager *) 0 ;
  operations_research::LocalSearchMonitor *arg2 = (operations_research::LocalSearchMonitor *) (operations_research::LocalSearchMonitor *)0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg4 = (operations_research::Assignment *) 0 ;
  int64_t arg5 ;
  int64_t arg6 ;
  bool result;
  
  arg1 = (operations_research::LocalSearchFilterManager *)jarg1; 
  arg2 = (operations_research::LocalSearchMonitor *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = (operations_research::Assignment *)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = (int64_t)jarg6; 
  result = (bool)(arg1)->Accept(arg2,(operations_research::Assignment const *)arg3,(operations_research::Assignment const *)arg4,arg5,arg6);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_Synchronize___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::LocalSearchFilterManager *arg1 = (operations_research::LocalSearchFilterManager *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilterManager *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  (arg1)->Synchronize((operations_research::Assignment const *)arg2,(operations_research::Assignment const *)arg3);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_GetSynchronizedObjectiveValue___(void * jarg1) {
  long long jresult ;
  operations_research::LocalSearchFilterManager *arg1 = (operations_research::LocalSearchFilterManager *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::LocalSearchFilterManager *)jarg1; 
  result = (int64_t)((operations_research::LocalSearchFilterManager const *)arg1)->GetSynchronizedObjectiveValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_GetAcceptedObjectiveValue___(void * jarg1) {
  long long jresult ;
  operations_research::LocalSearchFilterManager *arg1 = (operations_research::LocalSearchFilterManager *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::LocalSearchFilterManager *)jarg1; 
  result = (int64_t)((operations_research::LocalSearchFilterManager const *)arg1)->GetAcceptedObjectiveValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_LocalSearchFilterManager___(void * jarg1) {
  operations_research::LocalSearchFilterManager *arg1 = (operations_research::LocalSearchFilterManager *) 0 ;
  
  arg1 = (operations_research::LocalSearchFilterManager *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_director_connect___(void *objarg, SwigDirector_LocalSearchFilterManager::SWIG_Callback0_t callback0) {
  operations_research::LocalSearchFilterManager *obj = (operations_research::LocalSearchFilterManager *)objarg;
  SwigDirector_LocalSearchFilterManager *director = static_cast<SwigDirector_LocalSearchFilterManager *>(obj);
  director->swig_connect_director(callback0);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_IntVarLocalSearchFilter___(void * jarg1) {
  void * jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  operations_research::IntVarLocalSearchFilter *result = 0 ;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (operations_research::IntVarLocalSearchFilter *)new SwigDirector_IntVarLocalSearchFilter((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_IntVarLocalSearchFilter___(void * jarg1) {
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_Synchronize___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::Assignment *)jarg3; 
  (arg1)->Synchronize((operations_research::Assignment const *)arg2,(operations_research::Assignment const *)arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_AddVars___(void * jarg1, void * jarg2) {
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  (arg1)->AddVars((std::vector< operations_research::IntVar * > const &)*arg2);
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_Size___(void * jarg1) {
  int jresult ;
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  int result;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  result = (int)((operations_research::IntVarLocalSearchFilter const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_Var___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  int arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::IntVar *)((operations_research::IntVarLocalSearchFilter const *)arg1)->Var(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_Value___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::IntVarLocalSearchFilter const *)arg1)->Value(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_OnSynchronize___(void * jarg1, void * jarg2) {
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  SwigDirector_IntVarLocalSearchFilter *darg = 0;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  darg = dynamic_cast<SwigDirector_IntVarLocalSearchFilter *>(arg1);
  (darg)->OnSynchronize((operations_research::Assignment const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_OnSynchronizeSwigExplicitIntVarLocalSearchFilter___(void * jarg1, void * jarg2) {
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  SwigDirector_IntVarLocalSearchFilter *darg = 0;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  darg = dynamic_cast<SwigDirector_IntVarLocalSearchFilter *>(arg1);
  (darg)->OnSynchronizeSwigPublic((operations_research::Assignment const *)arg2);
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_Index___(void * jarg1, void * jarg2) {
  int jresult ;
  operations_research::IntVarLocalSearchFilter *arg1 = (operations_research::IntVarLocalSearchFilter *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int result;
  
  arg1 = (operations_research::IntVarLocalSearchFilter *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (int)operations_research_IntVarLocalSearchFilter_Index(arg1,arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_director_connect___(void *objarg, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback0_t callback0, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback1_t callback1, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback2_t callback2, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback3_t callback3, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback4_t callback4, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback5_t callback5, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback6_t callback6, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback7_t callback7, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback8_t callback8, SwigDirector_IntVarLocalSearchFilter::SWIG_Callback9_t callback9) {
  operations_research::IntVarLocalSearchFilter *obj = (operations_research::IntVarLocalSearchFilter *)objarg;
  SwigDirector_IntVarLocalSearchFilter *director = static_cast<SwigDirector_IntVarLocalSearchFilter *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_PropagationMonitor___(void * jarg1) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  std::string result;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  result = ((operations_research::PropagationMonitor const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_BeginConstraintInitialPropagation___(void * jarg1, void * jarg2) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  (arg1)->BeginConstraintInitialPropagation(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_EndConstraintInitialPropagation___(void * jarg1, void * jarg2) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  (arg1)->EndConstraintInitialPropagation(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_BeginNestedConstraintInitialPropagation___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::Constraint *arg3 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  arg3 = (operations_research::Constraint *)jarg3; 
  (arg1)->BeginNestedConstraintInitialPropagation(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_EndNestedConstraintInitialPropagation___(void * jarg1, void * jarg2, void * jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::Constraint *arg3 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  arg3 = (operations_research::Constraint *)jarg3; 
  (arg1)->EndNestedConstraintInitialPropagation(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RegisterDemon___(void * jarg1, void * jarg2) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->RegisterDemon(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_BeginDemonRun___(void * jarg1, void * jarg2) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->BeginDemonRun(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_EndDemonRun___(void * jarg1, void * jarg2) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) (operations_research::Demon *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->EndDemonRun(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_StartProcessingIntegerVariable___(void * jarg1, void * jarg2) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->StartProcessingIntegerVariable(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_EndProcessingIntegerVariable___(void * jarg1, void * jarg2) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->EndProcessingIntegerVariable(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_PushContext___(void * jarg1, char * jarg2) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->PushContext((std::string const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_PopContext___(void * jarg1) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  (arg1)->PopContext();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetMin__SWIG_0___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetMin(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetMax__SWIG_0___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetMax(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetRange__SWIG_0___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetRange(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetMin__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetMin(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetMax__SWIG_1___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetMax(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetRange__SWIG_1___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetRange(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RemoveValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->RemoveValue(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetValue(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RemoveInterval___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->RemoveInterval(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetValues___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->SetValues(arg2,(std::vector< int64_t > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RemoveValues___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::vector< int64_t > *arg3 = 0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  (arg1)->RemoveValues(arg2,(std::vector< int64_t > const &)*arg3);
  {
    delete arg3; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetStartMin___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetStartMin(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetStartMax___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetStartMax(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetStartRange___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetStartRange(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetEndMin___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetEndMin(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetEndMax___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetEndMax(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetEndRange___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetEndRange(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetDurationMin___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetDurationMin(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetDurationMax___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetDurationMax(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetDurationRange___(void * jarg1, void * jarg2, long long jarg3, long long jarg4) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetDurationRange(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SetPerformed___(void * jarg1, void * jarg2, unsigned int jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  bool arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = jarg3 ? true : false; 
  (arg1)->SetPerformed(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RankFirst___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  int arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->RankFirst(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RankNotFirst___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  int arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->RankNotFirst(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RankLast___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  int arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->RankLast(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RankNotLast___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  int arg3 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->RankNotLast(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_RankSequence___(void * jarg1, void * jarg2,  int length3, int*  jarg3,  int length4, int*  jarg4,  int length5, int*  jarg5) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  std::vector< int > *arg3 = 0 ;
  std::vector< int > *arg4 = 0 ;
  std::vector< int > *arg5 = 0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  
  arg3 = new std::vector<int>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<int>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  
  arg5 = new std::vector<int>;
  arg5->reserve(length5);
  for(int i = 0; i < length5; ++i) {
    arg5->emplace_back(jarg5[i]);
  }
  
  (arg1)->RankSequence(arg2,(std::vector< int > const &)*arg3,(std::vector< int > const &)*arg4,(std::vector< int > const &)*arg5);
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
  {
    delete arg5; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_Install___(void * jarg1) {
  operations_research::PropagationMonitor *arg1 = (operations_research::PropagationMonitor *) 0 ;
  
  arg1 = (operations_research::PropagationMonitor *)jarg1; 
  (arg1)->Install();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_LocalSearchMonitor___(void * jarg1) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  std::string result;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  result = ((operations_research::LocalSearchMonitor const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_BeginOperatorStart___(void * jarg1) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  (arg1)->BeginOperatorStart();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_EndOperatorStart___(void * jarg1) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  (arg1)->EndOperatorStart();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_BeginMakeNextNeighbor___(void * jarg1, void * jarg2) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  operations_research::LocalSearchOperator *arg2 = (operations_research::LocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  arg2 = (operations_research::LocalSearchOperator *)jarg2; 
  (arg1)->BeginMakeNextNeighbor((operations_research::LocalSearchOperator const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_EndMakeNextNeighbor___(void * jarg1, void * jarg2, unsigned int jarg3, void * jarg4, void * jarg5) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  operations_research::LocalSearchOperator *arg2 = (operations_research::LocalSearchOperator *) 0 ;
  bool arg3 ;
  operations_research::Assignment *arg4 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg5 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  arg2 = (operations_research::LocalSearchOperator *)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = (operations_research::Assignment *)jarg4; 
  arg5 = (operations_research::Assignment *)jarg5; 
  (arg1)->EndMakeNextNeighbor((operations_research::LocalSearchOperator const *)arg2,arg3,(operations_research::Assignment const *)arg4,(operations_research::Assignment const *)arg5);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_BeginFilterNeighbor___(void * jarg1, void * jarg2) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  operations_research::LocalSearchOperator *arg2 = (operations_research::LocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  arg2 = (operations_research::LocalSearchOperator *)jarg2; 
  (arg1)->BeginFilterNeighbor((operations_research::LocalSearchOperator const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_EndFilterNeighbor___(void * jarg1, void * jarg2, unsigned int jarg3) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  operations_research::LocalSearchOperator *arg2 = (operations_research::LocalSearchOperator *) 0 ;
  bool arg3 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  arg2 = (operations_research::LocalSearchOperator *)jarg2; 
  arg3 = jarg3 ? true : false; 
  (arg1)->EndFilterNeighbor((operations_research::LocalSearchOperator const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_BeginAcceptNeighbor___(void * jarg1, void * jarg2) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  operations_research::LocalSearchOperator *arg2 = (operations_research::LocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  arg2 = (operations_research::LocalSearchOperator *)jarg2; 
  (arg1)->BeginAcceptNeighbor((operations_research::LocalSearchOperator const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_EndAcceptNeighbor___(void * jarg1, void * jarg2, unsigned int jarg3) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  operations_research::LocalSearchOperator *arg2 = (operations_research::LocalSearchOperator *) 0 ;
  bool arg3 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  arg2 = (operations_research::LocalSearchOperator *)jarg2; 
  arg3 = jarg3 ? true : false; 
  (arg1)->EndAcceptNeighbor((operations_research::LocalSearchOperator const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_BeginFiltering___(void * jarg1, void * jarg2) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  operations_research::LocalSearchFilter *arg2 = (operations_research::LocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  arg2 = (operations_research::LocalSearchFilter *)jarg2; 
  (arg1)->BeginFiltering((operations_research::LocalSearchFilter const *)arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_EndFiltering___(void * jarg1, void * jarg2, unsigned int jarg3) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  operations_research::LocalSearchFilter *arg2 = (operations_research::LocalSearchFilter *) 0 ;
  bool arg3 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  arg2 = (operations_research::LocalSearchFilter *)jarg2; 
  arg3 = jarg3 ? true : false; 
  (arg1)->EndFiltering((operations_research::LocalSearchFilter const *)arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_Install___(void * jarg1) {
  operations_research::LocalSearchMonitor *arg1 = (operations_research::LocalSearchMonitor *) 0 ;
  
  arg1 = (operations_research::LocalSearchMonitor *)jarg1; 
  (arg1)->Install();
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_kUnboundBooleanVarValue_get___() {
  int jresult ;
  int result;
  
  result = (int)(int)operations_research::BooleanVar::kUnboundBooleanVarValue;
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_BooleanVar___(void * jarg1) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_Min___(void * jarg1) {
  long long jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = (int64_t)((operations_research::BooleanVar const *)arg1)->Min();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_SetMin___(void * jarg1, long long jarg2) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetMin(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_Max___(void * jarg1) {
  long long jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = (int64_t)((operations_research::BooleanVar const *)arg1)->Max();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_SetMax___(void * jarg1, long long jarg2) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetMax(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_SetRange___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->SetRange(arg2,arg3);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_Bound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  bool result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = (bool)((operations_research::BooleanVar const *)arg1)->Bound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_Value___(void * jarg1) {
  long long jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = (int64_t)((operations_research::BooleanVar const *)arg1)->Value();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_RemoveValue___(void * jarg1, long long jarg2) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  {
    operations_research::Solver* const solver = arg1->solver();
    FailureProtect protect;
    solver->set_fail_intercept([&protect]() {
      protect.JumpBack(); 
    });
    if (setjmp(protect.exception_buffer) == 0) {
      (arg1)->RemoveValue(arg2);
      solver->clear_fail_intercept();
    } else {
      solver->clear_fail_intercept();
      SWIG_CSharpSetPendingException(SWIG_CSharpApplicationException, "fail");
      return ;
    }
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_RemoveInterval___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->RemoveInterval(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_WhenBound___(void * jarg1, void * jarg2) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenBound(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_WhenRange___(void * jarg1, void * jarg2) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenRange(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_WhenDomain___(void * jarg1, void * jarg2) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  operations_research::Demon *arg2 = (operations_research::Demon *) 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (operations_research::Demon *)jarg2; 
  (arg1)->WhenDomain(arg2);
}
 
 
SWIGEXPORT unsigned long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_Size___(void * jarg1) {
  unsigned long long jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  uint64_t result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = (uint64_t)((operations_research::BooleanVar const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_Contains___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (bool)((operations_research::BooleanVar const *)arg1)->Contains(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  std::string result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = ((operations_research::BooleanVar const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_VarType___(void * jarg1) {
  int jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = (int)((operations_research::BooleanVar const *)arg1)->VarType();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_IsEqual___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->IsEqual(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_IsDifferent___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->IsDifferent(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_IsGreaterOrEqual___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->IsGreaterOrEqual(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_IsLessOrEqual___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)(arg1)->IsLessOrEqual(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_RestoreValue___(void * jarg1) {
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  (arg1)->RestoreValue();
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_BaseName___(void * jarg1) {
  char * jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  std::string result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = ((operations_research::BooleanVar const *)arg1)->BaseName();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_RawValue___(void * jarg1) {
  int jresult ;
  operations_research::BooleanVar *arg1 = (operations_research::BooleanVar *) 0 ;
  int result;
  
  arg1 = (operations_research::BooleanVar *)jarg1; 
  result = (int)((operations_research::BooleanVar const *)arg1)->RawValue();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_SymmetryBreaker___() {
  void * jresult ;
  operations_research::SymmetryBreaker *result = 0 ;
  
  result = (operations_research::SymmetryBreaker *)new SwigDirector_SymmetryBreaker();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SymmetryBreaker___(void * jarg1) {
  operations_research::SymmetryBreaker *arg1 = (operations_research::SymmetryBreaker *) 0 ;
  
  arg1 = (operations_research::SymmetryBreaker *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreaker_AddIntegerVariableEqualValueClause___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::SymmetryBreaker *arg1 = (operations_research::SymmetryBreaker *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::SymmetryBreaker *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->AddIntegerVariableEqualValueClause(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreaker_AddIntegerVariableGreaterOrEqualValueClause___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::SymmetryBreaker *arg1 = (operations_research::SymmetryBreaker *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::SymmetryBreaker *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->AddIntegerVariableGreaterOrEqualValueClause(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreaker_AddIntegerVariableLessOrEqualValueClause___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::SymmetryBreaker *arg1 = (operations_research::SymmetryBreaker *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::SymmetryBreaker *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->AddIntegerVariableLessOrEqualValueClause(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreaker_director_connect___(void *objarg, SwigDirector_SymmetryBreaker::SWIG_Callback0_t callback0, SwigDirector_SymmetryBreaker::SWIG_Callback1_t callback1, SwigDirector_SymmetryBreaker::SWIG_Callback2_t callback2, SwigDirector_SymmetryBreaker::SWIG_Callback3_t callback3, SwigDirector_SymmetryBreaker::SWIG_Callback4_t callback4, SwigDirector_SymmetryBreaker::SWIG_Callback5_t callback5, SwigDirector_SymmetryBreaker::SWIG_Callback6_t callback6, SwigDirector_SymmetryBreaker::SWIG_Callback7_t callback7) {
  operations_research::SymmetryBreaker *obj = (operations_research::SymmetryBreaker *)objarg;
  SwigDirector_SymmetryBreaker *director = static_cast<SwigDirector_SymmetryBreaker *>(obj);
  director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_SearchLog___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_EnterSearch___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->EnterSearch();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_ExitSearch___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->ExitSearch();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_AtSolution___(void * jarg1) {
  unsigned int jresult ;
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  bool result;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  result = (bool)(arg1)->AtSolution();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_BeginFail___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->BeginFail();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_NoMoreSolutions___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->NoMoreSolutions();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_AcceptUncheckedNeighbor___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->AcceptUncheckedNeighbor();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_ApplyDecision___(void * jarg1, void * jarg2) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->ApplyDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_RefuteDecision___(void * jarg1, void * jarg2) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  operations_research::Decision *arg2 = (operations_research::Decision *) (operations_research::Decision *)0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  arg2 = (operations_research::Decision *)jarg2; 
  (arg1)->RefuteDecision(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_OutputDecision___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->OutputDecision();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_Maintain___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->Maintain();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_BeginInitialPropagation___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->BeginInitialPropagation();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_EndInitialPropagation___(void * jarg1) {
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  (arg1)->EndInitialPropagation();
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::SearchLog *arg1 = (operations_research::SearchLog *) 0 ;
  std::string result;
  
  arg1 = (operations_research::SearchLog *)jarg1; 
  result = ((operations_research::SearchLog const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VOID_FALSE_CONSTRAINT_get___() {
  int jresult ;
  operations_research::ModelCache::VoidConstraintType result;
  
  result = (operations_research::ModelCache::VoidConstraintType)operations_research::ModelCache::VOID_FALSE_CONSTRAINT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VOID_TRUE_CONSTRAINT_get___() {
  int jresult ;
  operations_research::ModelCache::VoidConstraintType result;
  
  result = (operations_research::ModelCache::VoidConstraintType)operations_research::ModelCache::VOID_TRUE_CONSTRAINT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VOID_CONSTRAINT_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VoidConstraintType result;
  
  result = (operations_research::ModelCache::VoidConstraintType)operations_research::ModelCache::VOID_CONSTRAINT_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_EQUALITY_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstraintType result;
  
  result = (operations_research::ModelCache::VarConstantConstraintType)operations_research::ModelCache::VAR_CONSTANT_EQUALITY;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_GREATER_OR_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstraintType result;
  
  result = (operations_research::ModelCache::VarConstantConstraintType)operations_research::ModelCache::VAR_CONSTANT_GREATER_OR_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_LESS_OR_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstraintType result;
  
  result = (operations_research::ModelCache::VarConstantConstraintType)operations_research::ModelCache::VAR_CONSTANT_LESS_OR_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_NON_EQUALITY_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstraintType result;
  
  result = (operations_research::ModelCache::VarConstantConstraintType)operations_research::ModelCache::VAR_CONSTANT_NON_EQUALITY;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_CONSTRAINT_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstraintType result;
  
  result = (operations_research::ModelCache::VarConstantConstraintType)operations_research::ModelCache::VAR_CONSTANT_CONSTRAINT_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_CONSTANT_BETWEEN_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstantConstraintType result;
  
  result = (operations_research::ModelCache::VarConstantConstantConstraintType)operations_research::ModelCache::VAR_CONSTANT_CONSTANT_BETWEEN;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_CONSTANT_CONSTRAINT_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstantConstraintType result;
  
  result = (operations_research::ModelCache::VarConstantConstantConstraintType)operations_research::ModelCache::VAR_CONSTANT_CONSTANT_CONSTRAINT_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_EQUALITY_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstraintType result;
  
  result = (operations_research::ModelCache::ExprExprConstraintType)operations_research::ModelCache::EXPR_EXPR_EQUALITY;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_GREATER_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstraintType result;
  
  result = (operations_research::ModelCache::ExprExprConstraintType)operations_research::ModelCache::EXPR_EXPR_GREATER;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_GREATER_OR_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstraintType result;
  
  result = (operations_research::ModelCache::ExprExprConstraintType)operations_research::ModelCache::EXPR_EXPR_GREATER_OR_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_LESS_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstraintType result;
  
  result = (operations_research::ModelCache::ExprExprConstraintType)operations_research::ModelCache::EXPR_EXPR_LESS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_LESS_OR_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstraintType result;
  
  result = (operations_research::ModelCache::ExprExprConstraintType)operations_research::ModelCache::EXPR_EXPR_LESS_OR_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_NON_EQUALITY_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstraintType result;
  
  result = (operations_research::ModelCache::ExprExprConstraintType)operations_research::ModelCache::EXPR_EXPR_NON_EQUALITY;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_CONSTRAINT_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstraintType result;
  
  result = (operations_research::ModelCache::ExprExprConstraintType)operations_research::ModelCache::EXPR_EXPR_CONSTRAINT_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_OPPOSITE_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExpressionType)operations_research::ModelCache::EXPR_OPPOSITE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_ABS_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExpressionType)operations_research::ModelCache::EXPR_ABS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_SQUARE_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExpressionType)operations_research::ModelCache::EXPR_SQUARE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExpressionType)operations_research::ModelCache::EXPR_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_DIFFERENCE_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_DIFFERENCE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_PROD_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_PROD;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_DIV_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_DIV;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_MIN_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_MIN;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_SUM_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_SUM;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_IS_LESS_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_IS_LESS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_IS_LESS_OR_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_IS_LESS_OR_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_IS_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_IS_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_IS_NOT_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_IS_NOT_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprExpressionType)operations_research::ModelCache::EXPR_EXPR_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_CONSTANT_CONDITIONAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprConstantExpressionType)operations_research::ModelCache::EXPR_EXPR_CONSTANT_CONDITIONAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_EXPR_CONSTANT_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::ExprExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprExprConstantExpressionType)operations_research::ModelCache::EXPR_EXPR_CONSTANT_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_DIFFERENCE_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_DIFFERENCE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_DIVIDE_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_DIVIDE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_PROD_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_PROD;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_MIN_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_MIN;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_SUM_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_SUM;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_IS_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_IS_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_IS_NOT_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_IS_NOT_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_IS_GREATER_OR_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_IS_GREATER_OR_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_IS_LESS_OR_EQUAL_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_IS_LESS_OR_EQUAL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_EXPR_CONSTANT_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::ExprConstantExpressionType result;
  
  result = (operations_research::ModelCache::ExprConstantExpressionType)operations_research::ModelCache::EXPR_CONSTANT_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_CONSTANT_SEMI_CONTINUOUS_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstantExpressionType result;
  
  result = (operations_research::ModelCache::VarConstantConstantExpressionType)operations_research::ModelCache::VAR_CONSTANT_CONSTANT_SEMI_CONTINUOUS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_CONSTANT_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantConstantExpressionType result;
  
  result = (operations_research::ModelCache::VarConstantConstantExpressionType)operations_research::ModelCache::VAR_CONSTANT_CONSTANT_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_ARRAY_ELEMENT_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantArrayExpressionType result;
  
  result = (operations_research::ModelCache::VarConstantArrayExpressionType)operations_research::ModelCache::VAR_CONSTANT_ARRAY_ELEMENT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_CONSTANT_ARRAY_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VarConstantArrayExpressionType result;
  
  result = (operations_research::ModelCache::VarConstantArrayExpressionType)operations_research::ModelCache::VAR_CONSTANT_ARRAY_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_ARRAY_CONSTANT_ARRAY_SCAL_PROD_get___() {
  int jresult ;
  operations_research::ModelCache::VarArrayConstantArrayExpressionType result;
  
  result = (operations_research::ModelCache::VarArrayConstantArrayExpressionType)operations_research::ModelCache::VAR_ARRAY_CONSTANT_ARRAY_SCAL_PROD;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_ARRAY_CONSTANT_ARRAY_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VarArrayConstantArrayExpressionType result;
  
  result = (operations_research::ModelCache::VarArrayConstantArrayExpressionType)operations_research::ModelCache::VAR_ARRAY_CONSTANT_ARRAY_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_ARRAY_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VarArrayExpressionType result;
  
  result = (operations_research::ModelCache::VarArrayExpressionType)operations_research::ModelCache::VAR_ARRAY_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_ARRAY_MIN_get___() {
  int jresult ;
  operations_research::ModelCache::VarArrayExpressionType result;
  
  result = (operations_research::ModelCache::VarArrayExpressionType)operations_research::ModelCache::VAR_ARRAY_MIN;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_ARRAY_SUM_get___() {
  int jresult ;
  operations_research::ModelCache::VarArrayExpressionType result;
  
  result = (operations_research::ModelCache::VarArrayExpressionType)operations_research::ModelCache::VAR_ARRAY_SUM;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_ARRAY_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VarArrayExpressionType result;
  
  result = (operations_research::ModelCache::VarArrayExpressionType)operations_research::ModelCache::VAR_ARRAY_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_ARRAY_CONSTANT_INDEX_get___() {
  int jresult ;
  operations_research::ModelCache::VarArrayConstantExpressionType result;
  
  result = (operations_research::ModelCache::VarArrayConstantExpressionType)operations_research::ModelCache::VAR_ARRAY_CONSTANT_INDEX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_VAR_ARRAY_CONSTANT_EXPRESSION_MAX_get___() {
  int jresult ;
  operations_research::ModelCache::VarArrayConstantExpressionType result;
  
  result = (operations_research::ModelCache::VarArrayConstantExpressionType)operations_research::ModelCache::VAR_ARRAY_CONSTANT_EXPRESSION_MAX;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_ModelCache___(void * jarg1) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_Clear___(void * jarg1) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  (arg1)->Clear();
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindVoidConstraint___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::ModelCache::VoidConstraintType arg2 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::ModelCache::VoidConstraintType)jarg2; 
  result = (operations_research::Constraint *)((operations_research::ModelCache const *)arg1)->FindVoidConstraint(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertVoidConstraint___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::ModelCache::VoidConstraintType arg3 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  arg3 = (operations_research::ModelCache::VoidConstraintType)jarg3; 
  (arg1)->InsertVoidConstraint(arg2,arg3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindVarConstantConstraint___(void * jarg1, void * jarg2, long long jarg3, int jarg4) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  operations_research::ModelCache::VarConstantConstraintType arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::ModelCache::VarConstantConstraintType)jarg4; 
  result = (operations_research::Constraint *)((operations_research::ModelCache const *)arg1)->FindVarConstantConstraint(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertVarConstantConstraint___(void * jarg1, void * jarg2, void * jarg3, long long jarg4, int jarg5) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  operations_research::ModelCache::VarConstantConstraintType arg5 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::ModelCache::VarConstantConstraintType)jarg5; 
  (arg1)->InsertVarConstantConstraint(arg2,arg3,arg4,arg5);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindVarConstantConstantConstraint___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, int jarg5) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::ModelCache::VarConstantConstantConstraintType arg5 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::ModelCache::VarConstantConstantConstraintType)jarg5; 
  result = (operations_research::Constraint *)((operations_research::ModelCache const *)arg1)->FindVarConstantConstantConstraint(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertVarConstantConstantConstraint___(void * jarg1, void * jarg2, void * jarg3, long long jarg4, long long jarg5, int jarg6) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  int64_t arg5 ;
  operations_research::ModelCache::VarConstantConstantConstraintType arg6 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = (operations_research::ModelCache::VarConstantConstantConstraintType)jarg6; 
  (arg1)->InsertVarConstantConstantConstraint(arg2,arg3,arg4,arg5,arg6);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindExprExprConstraint___(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::ModelCache::ExprExprConstraintType arg4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::ModelCache::ExprExprConstraintType)jarg4; 
  result = (operations_research::Constraint *)((operations_research::ModelCache const *)arg1)->FindExprExprConstraint(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertExprExprConstraint___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::Constraint *arg2 = (operations_research::Constraint *) (operations_research::Constraint *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg4 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::ModelCache::ExprExprConstraintType arg5 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::Constraint *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntExpr *)jarg4; 
  arg5 = (operations_research::ModelCache::ExprExprConstraintType)jarg5; 
  (arg1)->InsertExprExprConstraint(arg2,arg3,arg4,arg5);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindExprExpression___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::ModelCache::ExprExpressionType arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::ModelCache::ExprExpressionType)jarg3; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindExprExpression(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertExprExpression___(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::ModelCache::ExprExpressionType arg4 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::ModelCache::ExprExpressionType)jarg4; 
  (arg1)->InsertExprExpression(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindExprConstantExpression___(void * jarg1, void * jarg2, long long jarg3, int jarg4) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg3 ;
  operations_research::ModelCache::ExprConstantExpressionType arg4 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::ModelCache::ExprConstantExpressionType)jarg4; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindExprConstantExpression(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertExprConstantExpression___(void * jarg1, void * jarg2, void * jarg3, long long jarg4, int jarg5) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg4 ;
  operations_research::ModelCache::ExprConstantExpressionType arg5 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::ModelCache::ExprConstantExpressionType)jarg5; 
  (arg1)->InsertExprConstantExpression(arg2,arg3,arg4,arg5);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindExprExprExpression___(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::ModelCache::ExprExprExpressionType arg4 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::ModelCache::ExprExprExpressionType)jarg4; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindExprExprExpression(arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertExprExprExpression___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg4 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::ModelCache::ExprExprExpressionType arg5 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntExpr *)jarg4; 
  arg5 = (operations_research::ModelCache::ExprExprExpressionType)jarg5; 
  (arg1)->InsertExprExprExpression(arg2,arg3,arg4,arg5);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindExprExprConstantExpression___(void * jarg1, void * jarg2, void * jarg3, long long jarg4, int jarg5) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg4 ;
  operations_research::ModelCache::ExprExprConstantExpressionType arg5 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::ModelCache::ExprExprConstantExpressionType)jarg5; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindExprExprConstantExpression(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertExprExprConstantExpression___(void * jarg1, void * jarg2, void * jarg3, void * jarg4, long long jarg5, int jarg6) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg3 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntExpr *arg4 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  int64_t arg5 ;
  operations_research::ModelCache::ExprExprConstantExpressionType arg6 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntExpr *)jarg3; 
  arg4 = (operations_research::IntExpr *)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = (operations_research::ModelCache::ExprExprConstantExpressionType)jarg6; 
  (arg1)->InsertExprExprConstantExpression(arg2,arg3,arg4,arg5,arg6);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindVarConstantConstantExpression___(void * jarg1, void * jarg2, long long jarg3, long long jarg4, int jarg5) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::ModelCache::VarConstantConstantExpressionType arg5 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::ModelCache::VarConstantConstantExpressionType)jarg5; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindVarConstantConstantExpression(arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertVarConstantConstantExpression___(void * jarg1, void * jarg2, void * jarg3, long long jarg4, long long jarg5, int jarg6) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  int64_t arg4 ;
  int64_t arg5 ;
  operations_research::ModelCache::VarConstantConstantExpressionType arg6 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = (int64_t)jarg5; 
  arg6 = (operations_research::ModelCache::VarConstantConstantExpressionType)jarg6; 
  (arg1)->InsertVarConstantConstantExpression(arg2,arg3,arg4,arg5,arg6);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindVarConstantArrayExpression___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, int jarg4) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::ModelCache::VarConstantArrayExpressionType arg4 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (operations_research::ModelCache::VarConstantArrayExpressionType)jarg4; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindVarConstantArrayExpression(arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertVarConstantArrayExpression___(void * jarg1, void * jarg2, void * jarg3,  int length4, int64_t*  jarg4, int jarg5) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  operations_research::IntVar *arg3 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  std::vector< int64_t > *arg4 = 0 ;
  operations_research::ModelCache::VarConstantArrayExpressionType arg5 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (operations_research::IntVar *)jarg3; 
  
  arg4 = new std::vector<int64_t>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  arg5 = (operations_research::ModelCache::VarConstantArrayExpressionType)jarg5; 
  (arg1)->InsertVarConstantArrayExpression(arg2,arg3,(std::vector< int64_t > const &)*arg4,arg5);
  {
    delete arg4; 
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindVarArrayExpression___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  operations_research::ModelCache::VarArrayExpressionType arg3 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (operations_research::ModelCache::VarArrayExpressionType)jarg3; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindVarArrayExpression((std::vector< operations_research::IntVar * > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertVarArrayExpression___(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  operations_research::ModelCache::VarArrayExpressionType arg4 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  arg4 = (operations_research::ModelCache::VarArrayExpressionType)jarg4; 
  (arg1)->InsertVarArrayExpression(arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindVarArrayConstantArrayExpression___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3, int jarg4) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  std::vector< int64_t > *arg3 = 0 ;
  operations_research::ModelCache::VarArrayConstantArrayExpressionType arg4 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  
  arg3 = new std::vector<int64_t>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  arg4 = (operations_research::ModelCache::VarArrayConstantArrayExpressionType)jarg4; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindVarArrayConstantArrayExpression((std::vector< operations_research::IntVar * > const &)*arg2,(std::vector< int64_t > const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertVarArrayConstantArrayExpression___(void * jarg1, void * jarg2, void * jarg3,  int length4, int64_t*  jarg4, int jarg5) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  std::vector< int64_t > *arg4 = 0 ;
  operations_research::ModelCache::VarArrayConstantArrayExpressionType arg5 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  
  arg4 = new std::vector<int64_t>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  arg5 = (operations_research::ModelCache::VarArrayConstantArrayExpressionType)jarg5; 
  (arg1)->InsertVarArrayConstantArrayExpression(arg2,(std::vector< operations_research::IntVar * > const &)*arg3,(std::vector< int64_t > const &)*arg4,arg5);
  {
    delete arg4; 
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_FindVarArrayConstantExpression___(void * jarg1, void * jarg2, long long jarg3, int jarg4) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  std::vector< operations_research::IntVar * > *arg2 = 0 ;
  int64_t arg3 ;
  operations_research::ModelCache::VarArrayConstantExpressionType arg4 ;
  operations_research::IntExpr *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (std::vector< operations_research::IntVar * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  arg4 = (operations_research::ModelCache::VarArrayConstantExpressionType)jarg4; 
  result = (operations_research::IntExpr *)((operations_research::ModelCache const *)arg1)->FindVarArrayConstantExpression((std::vector< operations_research::IntVar * > const &)*arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_InsertVarArrayConstantExpression___(void * jarg1, void * jarg2, void * jarg3, long long jarg4, int jarg5) {
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::IntExpr *arg2 = (operations_research::IntExpr *) (operations_research::IntExpr *)0 ;
  std::vector< operations_research::IntVar * > *arg3 = 0 ;
  int64_t arg4 ;
  operations_research::ModelCache::VarArrayConstantExpressionType arg5 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  arg2 = (operations_research::IntExpr *)jarg2; 
  arg3 = (std::vector< operations_research::IntVar * > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return ;
  } 
  arg4 = (int64_t)jarg4; 
  arg5 = (operations_research::ModelCache::VarArrayConstantExpressionType)jarg5; 
  (arg1)->InsertVarArrayConstantExpression(arg2,(std::vector< operations_research::IntVar * > const &)*arg3,arg4,arg5);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelCache_solver___(void * jarg1) {
  void * jresult ;
  operations_research::ModelCache *arg1 = (operations_research::ModelCache *) 0 ;
  operations_research::Solver *result = 0 ;
  
  arg1 = (operations_research::ModelCache *)jarg1; 
  result = (operations_research::Solver *)((operations_research::ModelCache const *)arg1)->solver();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RevPartialSequence__SWIG_0___( int length1, int*  jarg1) {
  void * jresult ;
  std::vector< int > *arg1 = 0 ;
  operations_research::RevPartialSequence *result = 0 ;
  
  
  arg1 = new std::vector<int>;
  arg1->reserve(length1);
  for(int i = 0; i < length1; ++i) {
    arg1->emplace_back(jarg1[i]);
  }
  
  result = (operations_research::RevPartialSequence *)new operations_research::RevPartialSequence((std::vector< int > const &)*arg1);
  jresult = (void *)result; 
  {
    delete arg1; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RevPartialSequence__SWIG_1___(int jarg1) {
  void * jresult ;
  int arg1 ;
  operations_research::RevPartialSequence *result = 0 ;
  
  arg1 = (int)jarg1; 
  result = (operations_research::RevPartialSequence *)new operations_research::RevPartialSequence(arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RevPartialSequence___(void * jarg1) {
  operations_research::RevPartialSequence *arg1 = (operations_research::RevPartialSequence *) 0 ;
  
  arg1 = (operations_research::RevPartialSequence *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevPartialSequence_NumFirstRanked___(void * jarg1) {
  int jresult ;
  operations_research::RevPartialSequence *arg1 = (operations_research::RevPartialSequence *) 0 ;
  int result;
  
  arg1 = (operations_research::RevPartialSequence *)jarg1; 
  result = (int)((operations_research::RevPartialSequence const *)arg1)->NumFirstRanked();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevPartialSequence_NumLastRanked___(void * jarg1) {
  int jresult ;
  operations_research::RevPartialSequence *arg1 = (operations_research::RevPartialSequence *) 0 ;
  int result;
  
  arg1 = (operations_research::RevPartialSequence *)jarg1; 
  result = (int)((operations_research::RevPartialSequence const *)arg1)->NumLastRanked();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevPartialSequence_Size___(void * jarg1) {
  int jresult ;
  operations_research::RevPartialSequence *arg1 = (operations_research::RevPartialSequence *) 0 ;
  int result;
  
  arg1 = (operations_research::RevPartialSequence *)jarg1; 
  result = (int)((operations_research::RevPartialSequence const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevPartialSequence_RankFirst___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::RevPartialSequence *arg1 = (operations_research::RevPartialSequence *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  int arg3 ;
  
  arg1 = (operations_research::RevPartialSequence *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->RankFirst(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevPartialSequence_RankLast___(void * jarg1, void * jarg2, int jarg3) {
  operations_research::RevPartialSequence *arg1 = (operations_research::RevPartialSequence *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  int arg3 ;
  
  arg1 = (operations_research::RevPartialSequence *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->RankLast(arg2,arg3);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevPartialSequence_IsRanked___(void * jarg1, int jarg2) {
  unsigned int jresult ;
  operations_research::RevPartialSequence *arg1 = (operations_research::RevPartialSequence *) 0 ;
  int arg2 ;
  bool result;
  
  arg1 = (operations_research::RevPartialSequence *)jarg1; 
  arg2 = (int)jarg2; 
  result = (bool)((operations_research::RevPartialSequence const *)arg1)->IsRanked(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevPartialSequence_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::RevPartialSequence *arg1 = (operations_research::RevPartialSequence *) 0 ;
  std::string result;
  
  arg1 = (operations_research::RevPartialSequence *)jarg1; 
  result = ((operations_research::RevPartialSequence const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AreAllBound___(void * jarg1) {
  unsigned int jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (bool)operations_research::AreAllBound((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AreAllBooleans___(void * jarg1) {
  unsigned int jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  bool result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (bool)operations_research::AreAllBooleans((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AreAllBoundTo___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  arg2 = (int64_t)jarg2; 
  result = (bool)operations_research::AreAllBoundTo((std::vector< operations_research::IntVar * > const &)*arg1,arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_MaxVarArray___(void * jarg1) {
  long long jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  int64_t result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (int64_t)operations_research::MaxVarArray((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_MinVarArray___(void * jarg1) {
  long long jresult ;
  std::vector< operations_research::IntVar * > *arg1 = 0 ;
  int64_t result;
  
  arg1 = (std::vector< operations_research::IntVar * > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::IntVar * > const & type is null", 0);
    return 0;
  } 
  result = (int64_t)operations_research::MinVarArray((std::vector< operations_research::IntVar * > const &)*arg1);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PosIntDivUp___(long long jarg1, long long jarg2) {
  long long jresult ;
  int64_t arg1 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (int64_t)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)operations_research::PosIntDivUp(arg1,arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PosIntDivDown___(long long jarg1, long long jarg2) {
  long long jresult ;
  int64_t arg1 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (int64_t)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)operations_research::PosIntDivDown(arg1,arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ToInt64Vector___( int length1, int*  jarg1) {
  void* jresult ;
  std::vector< int > *arg1 = 0 ;
  std::vector< int64_t > result;
  
  
  arg1 = new std::vector<int>;
  arg1->reserve(length1);
  for(int i = 0; i < length1; ++i) {
    arg1->emplace_back(jarg1[i]);
  }
  
  result = operations_research::ToInt64Vector((std::vector< int > const &)*arg1);
  
  jresult = new std::vector< int64_t >((const std::vector< int64_t> &)result);
  
  {
    delete arg1; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RevInteger___(long long jarg1) {
  void * jresult ;
  long *arg1 = 0 ;
  long temp1 ;
  operations_research::Rev< int64_t > *result = 0 ;
  
  temp1 = (long)jarg1; 
  arg1 = &temp1; 
  result = (operations_research::Rev< int64_t > *)new operations_research::Rev< int64_t >((long const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevInteger_Value___(void * jarg1) {
  long long jresult ;
  operations_research::Rev< int64_t > *arg1 = (operations_research::Rev< int64_t > *) 0 ;
  long *result = 0 ;
  
  arg1 = (operations_research::Rev< int64_t > *)jarg1; 
  result = (long *) &((operations_research::Rev< int64_t > const *)arg1)->Value();
  jresult = *result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevInteger_SetValue___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::Rev< int64_t > *arg1 = (operations_research::Rev< int64_t > *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  long *arg3 = 0 ;
  long temp3 ;
  
  arg1 = (operations_research::Rev< int64_t > *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  temp3 = (long)jarg3; 
  arg3 = &temp3; 
  (arg1)->SetValue(arg2,(long const &)*arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RevInteger___(void * jarg1) {
  operations_research::Rev< int64_t > *arg1 = (operations_research::Rev< int64_t > *) 0 ;
  
  arg1 = (operations_research::Rev< int64_t > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RevBool___(unsigned int jarg1) {
  void * jresult ;
  bool *arg1 = 0 ;
  bool temp1 ;
  operations_research::Rev< bool > *result = 0 ;
  
  temp1 = jarg1 ? true : false; 
  arg1 = &temp1; 
  result = (operations_research::Rev< bool > *)new operations_research::Rev< bool >((bool const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevBool_Value___(void * jarg1) {
  unsigned int jresult ;
  operations_research::Rev< bool > *arg1 = (operations_research::Rev< bool > *) 0 ;
  bool *result = 0 ;
  
  arg1 = (operations_research::Rev< bool > *)jarg1; 
  result = (bool *) &((operations_research::Rev< bool > const *)arg1)->Value();
  jresult = *result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RevBool_SetValue___(void * jarg1, void * jarg2, unsigned int jarg3) {
  operations_research::Rev< bool > *arg1 = (operations_research::Rev< bool > *) 0 ;
  operations_research::Solver *arg2 = (operations_research::Solver *) (operations_research::Solver *)0 ;
  bool *arg3 = 0 ;
  bool temp3 ;
  
  arg1 = (operations_research::Rev< bool > *)jarg1; 
  arg2 = (operations_research::Solver *)jarg2; 
  temp3 = jarg3 ? true : false; 
  arg3 = &temp3; 
  (arg1)->SetValue(arg2,(bool const &)*arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RevBool___(void * jarg1) {
  operations_research::Rev< bool > *arg1 = (operations_research::Rev< bool > *) 0 ;
  
  arg1 = (operations_research::Rev< bool > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_AssignmentIntContainer___() {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *result = 0 ;
  
  result = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)new operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Add___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (operations_research::IntVarElement *)(arg1)->Add(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_FastAdd___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (operations_research::IntVarElement *)(arg1)->FastAdd(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_AddAtPosition___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  int arg3 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::IntVarElement *)(arg1)->AddAtPosition(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Clear___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  (arg1)->Clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Resize___(void * jarg1, unsigned long jarg2) {
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  size_t arg2 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (size_t)jarg2; 
  (arg1)->Resize(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Empty___(void * jarg1) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const *)arg1)->Empty();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_CopyIntersection___(void * jarg1, void * jarg2) {
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg2 = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const & type is null", 0);
    return ;
  } 
  (arg1)->CopyIntersection((operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Copy___(void * jarg1, void * jarg2) {
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg2 = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const & type is null", 0);
    return ;
  } 
  (arg1)->Copy((operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const &)*arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const *)arg1)->Contains((operations_research::IntVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Element__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  result = (operations_research::IntVarElement *) &((operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const *)arg1)->Element((operations_research::IntVar const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Element__SWIG_1___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  int arg2 ;
  operations_research::IntVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::IntVarElement *) &((operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const *)arg1)->Element(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Size___(void * jarg1) {
  int jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  int result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  result = (int)((operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Store___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  (arg1)->Store();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_Restore___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  (arg1)->Restore();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntContainer_AreAllElementsBound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > const *)arg1)->AreAllElementsBound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_AssignmentIntContainer___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntVar,operations_research::IntVarElement > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_AssignmentIntervalContainer___() {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *result = 0 ;
  
  result = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)new operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Add___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVarElement *)(arg1)->Add(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_FastAdd___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVarElement *)(arg1)->FastAdd(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_AddAtPosition___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) 0 ;
  int arg3 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::IntervalVarElement *)(arg1)->AddAtPosition(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Clear___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  (arg1)->Clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Resize___(void * jarg1, unsigned long jarg2) {
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  size_t arg2 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (size_t)jarg2; 
  (arg1)->Resize(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Empty___(void * jarg1) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const *)arg1)->Empty();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_CopyIntersection___(void * jarg1, void * jarg2) {
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg2 = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const & type is null", 0);
    return ;
  } 
  (arg1)->CopyIntersection((operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Copy___(void * jarg1, void * jarg2) {
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg2 = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const & type is null", 0);
    return ;
  } 
  (arg1)->Copy((operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const &)*arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const *)arg1)->Contains((operations_research::IntervalVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Element__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  result = (operations_research::IntervalVarElement *) &((operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const *)arg1)->Element((operations_research::IntervalVar const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Element__SWIG_1___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  int arg2 ;
  operations_research::IntervalVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::IntervalVarElement *) &((operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const *)arg1)->Element(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Size___(void * jarg1) {
  int jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  int result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  result = (int)((operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Store___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  (arg1)->Store();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_Restore___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  (arg1)->Restore();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentIntervalContainer_AreAllElementsBound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > const *)arg1)->AreAllElementsBound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_AssignmentIntervalContainer___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::IntervalVar,operations_research::IntervalVarElement > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_AssignmentSequenceContainer___() {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *result = 0 ;
  
  result = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)new operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement >();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Add___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) 0 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (operations_research::SequenceVarElement *)(arg1)->Add(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_FastAdd___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) 0 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (operations_research::SequenceVarElement *)(arg1)->FastAdd(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_AddAtPosition___(void * jarg1, void * jarg2, int jarg3) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) 0 ;
  int arg3 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  arg3 = (int)jarg3; 
  result = (operations_research::SequenceVarElement *)(arg1)->AddAtPosition(arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Clear___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  (arg1)->Clear();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Resize___(void * jarg1, unsigned long jarg2) {
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  size_t arg2 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (size_t)jarg2; 
  (arg1)->Resize(arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Empty___(void * jarg1) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const *)arg1)->Empty();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_CopyIntersection___(void * jarg1, void * jarg2) {
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg2 = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const & type is null", 0);
    return ;
  } 
  (arg1)->CopyIntersection((operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const &)*arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Copy___(void * jarg1, void * jarg2) {
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg2 = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const & type is null", 0);
    return ;
  } 
  (arg1)->Copy((operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const &)*arg2);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Contains___(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const *)arg1)->Contains((operations_research::SequenceVar const *)arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Element__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  operations_research::SequenceVar *arg2 = (operations_research::SequenceVar *) (operations_research::SequenceVar *)0 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (operations_research::SequenceVar *)jarg2; 
  result = (operations_research::SequenceVarElement *) &((operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const *)arg1)->Element((operations_research::SequenceVar const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Element__SWIG_1___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  int arg2 ;
  operations_research::SequenceVarElement *result = 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::SequenceVarElement *) &((operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const *)arg1)->Element(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Size___(void * jarg1) {
  int jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  int result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  result = (int)((operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Store___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  (arg1)->Store();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_Restore___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  (arg1)->Restore();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_AssignmentSequenceContainer_AreAllElementsBound___(void * jarg1) {
  unsigned int jresult ;
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  bool result;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  result = (bool)((operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > const *)arg1)->AreAllElementsBound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_AssignmentSequenceContainer___(void * jarg1) {
  operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *) 0 ;
  
  arg1 = (operations_research::AssignmentContainer< operations_research::SequenceVar,operations_research::SequenceVarElement > *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RoutingIndexManager__SWIG_0___(int jarg1, int jarg2, int jarg3) {
  void * jresult ;
  int arg1 ;
  int arg2 ;
  operations_research::RoutingIndexManager::NodeIndex arg3 ;
  operations_research::RoutingIndexManager *result = 0 ;
  
  arg1 = (int)jarg1; 
  arg2 = (int)jarg2; 
  {
    arg3 = operations_research::RoutingNodeIndex(jarg3);
  }
  result = (operations_research::RoutingIndexManager *)new operations_research::RoutingIndexManager(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RoutingIndexManager__SWIG_1___(int jarg1, int jarg2,  int length3, int*  jarg3,  int length4, int*  jarg4) {
  void * jresult ;
  int arg1 ;
  int arg2 ;
  std::vector< operations_research::RoutingIndexManager::NodeIndex > *arg3 = 0 ;
  std::vector< operations_research::RoutingIndexManager::NodeIndex > *arg4 = 0 ;
  operations_research::RoutingIndexManager *result = 0 ;
  
  arg1 = (int)jarg1; 
  arg2 = (int)jarg2; 
  
  arg3 = new std::vector<operations_research::RoutingNodeIndex>;
  arg3->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    arg3->emplace_back(jarg3[i]);
  }
  
  
  arg4 = new std::vector<operations_research::RoutingNodeIndex>;
  arg4->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    arg4->emplace_back(jarg4[i]);
  }
  
  result = (operations_research::RoutingIndexManager *)new operations_research::RoutingIndexManager(arg1,arg2,(std::vector< operations_research::RoutingIndexManager::NodeIndex > const &)*arg3,(std::vector< operations_research::RoutingIndexManager::NodeIndex > const &)*arg4);
  jresult = (void *)result; 
  {
    delete arg3; 
  }
  {
    delete arg4; 
  }
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RoutingIndexManager___(void * jarg1) {
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingIndexManager_GetNumberOfNodes___(void * jarg1) {
  int jresult ;
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  result = (int)((operations_research::RoutingIndexManager const *)arg1)->num_nodes();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingIndexManager_GetNumberOfVehicles___(void * jarg1) {
  int jresult ;
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  result = (int)((operations_research::RoutingIndexManager const *)arg1)->num_vehicles();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingIndexManager_GetNumberOfIndices___(void * jarg1) {
  int jresult ;
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  result = (int)((operations_research::RoutingIndexManager const *)arg1)->num_indices();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingIndexManager_GetStartIndex___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::RoutingIndexManager const *)arg1)->GetStartIndex(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingIndexManager_GetEndIndex___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::RoutingIndexManager const *)arg1)->GetEndIndex(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingIndexManager_NodeToIndex___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  operations_research::RoutingIndexManager::NodeIndex arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  {
    arg2 = operations_research::RoutingNodeIndex(jarg2);
  }
  result = (int64_t)((operations_research::RoutingIndexManager const *)arg1)->NodeToIndex(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingIndexManager_NodesToIndices___(void * jarg1,  int length2, int*  jarg2) {
  void* jresult ;
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  std::vector< operations_research::RoutingIndexManager::NodeIndex > *arg2 = 0 ;
  std::vector< int64_t > result;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  
  arg2 = new std::vector<operations_research::RoutingNodeIndex>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = ((operations_research::RoutingIndexManager const *)arg1)->NodesToIndices((std::vector< operations_research::RoutingIndexManager::NodeIndex > const &)*arg2);
  
  jresult = new std::vector< int64_t >((const std::vector< int64_t> &)result);
  
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingIndexManager_IndexToNode___(void * jarg1, long long jarg2) {
  int jresult ;
  operations_research::RoutingIndexManager *arg1 = (operations_research::RoutingIndexManager *) 0 ;
  int64_t arg2 ;
  operations_research::RoutingIndexManager::NodeIndex result;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = ((operations_research::RoutingIndexManager const *)arg1)->IndexToNode(arg2);
  {
    jresult = (&result)->value();
  }
  return jresult;
}
 
 
SWIGEXPORT uint8_t* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultRoutingModelParameters___() {
  uint8_t* jresult ;
  operations_research::RoutingModelParameters result;
  
  result = operations_research::DefaultRoutingModelParameters();
  {
    const long size = (&result)->ByteSizeLong();
    jresult = new uint8_t[size + 4];
    (&result)->SerializeWithCachedSizesToArray(jresult + 4);
    jresult[0] = size & 0xFF;
    jresult[1] = (size >> 8) & 0xFF;
    jresult[2] = (size >> 16) & 0xFF;
    jresult[3] = (size >> 24) & 0xFF;
  }
  return jresult;
}
 
 
SWIGEXPORT uint8_t* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DefaultRoutingSearchParameters___() {
  uint8_t* jresult ;
  operations_research::RoutingSearchParameters result;
  
  result = operations_research::DefaultRoutingSearchParameters();
  {
    const long size = (&result)->ByteSizeLong();
    jresult = new uint8_t[size + 4];
    (&result)->SerializeWithCachedSizesToArray(jresult + 4);
    jresult[0] = size & 0xFF;
    jresult[1] = (size >> 8) & 0xFF;
    jresult[2] = (size >> 16) & 0xFF;
    jresult[3] = (size >> 24) & 0xFF;
  }
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_FindErrorInRoutingSearchParameters___(int search_parameters_size, uint8_t* jarg1) {
  char * jresult ;
  operations_research::RoutingSearchParameters *arg1 = 0 ;
  std::string result;
  
  {
    arg1 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg1->ParseFromArray(jarg1, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  result = operations_research::FindErrorInRoutingSearchParameters((operations_research::RoutingSearchParameters const &)*arg1);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  {
    delete arg1;
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ROUTING_NOT_SOLVED_get___() {
  int jresult ;
  operations_research::RoutingModel::Status result;
  
  result = (operations_research::RoutingModel::Status)operations_research::RoutingModel::ROUTING_NOT_SOLVED;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ROUTING_SUCCESS_get___() {
  int jresult ;
  operations_research::RoutingModel::Status result;
  
  result = (operations_research::RoutingModel::Status)operations_research::RoutingModel::ROUTING_SUCCESS;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ROUTING_FAIL_get___() {
  int jresult ;
  operations_research::RoutingModel::Status result;
  
  result = (operations_research::RoutingModel::Status)operations_research::RoutingModel::ROUTING_FAIL;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ROUTING_FAIL_TIMEOUT_get___() {
  int jresult ;
  operations_research::RoutingModel::Status result;
  
  result = (operations_research::RoutingModel::Status)operations_research::RoutingModel::ROUTING_FAIL_TIMEOUT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ROUTING_INVALID_get___() {
  int jresult ;
  operations_research::RoutingModel::Status result;
  
  result = (operations_research::RoutingModel::Status)operations_research::RoutingModel::ROUTING_INVALID;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER_get___() {
  int jresult ;
  operations_research::RoutingModel::PickupAndDeliveryPolicy result;
  
  result = (operations_research::RoutingModel::PickupAndDeliveryPolicy)operations_research::RoutingModel::PICKUP_AND_DELIVERY_NO_ORDER;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_PICKUP_AND_DELIVERY_LIFO_get___() {
  int jresult ;
  operations_research::RoutingModel::PickupAndDeliveryPolicy result;
  
  result = (operations_research::RoutingModel::PickupAndDeliveryPolicy)operations_research::RoutingModel::PICKUP_AND_DELIVERY_LIFO;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_PICKUP_AND_DELIVERY_FIFO_get___() {
  int jresult ;
  operations_research::RoutingModel::PickupAndDeliveryPolicy result;
  
  result = (operations_research::RoutingModel::PickupAndDeliveryPolicy)operations_research::RoutingModel::PICKUP_AND_DELIVERY_FIFO;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_VehicleClassEntry_vehicle_class_set___(void * jarg1, int jarg2) {
  operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *)jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->vehicle_class = arg2;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_VehicleClassEntry_vehicle_class_get___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *)jarg1; 
  result = (int) ((arg1)->vehicle_class);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_VehicleClassEntry_fixed_cost_set___(void * jarg1, long long jarg2) {
  operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *)jarg1; 
  arg2 = (int64_t)jarg2; 
  if (arg1) (arg1)->fixed_cost = arg2;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_VehicleClassEntry_fixed_cost_get___(void * jarg1) {
  long long jresult ;
  operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *)jarg1; 
  result = (int64_t) ((arg1)->fixed_cost);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RoutingModel_VehicleTypeContainer_VehicleClassEntry___() {
  void * jresult ;
  operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *result = 0 ;
  
  result = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *)new operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RoutingModel_VehicleTypeContainer_VehicleClassEntry___(void * jarg1) {
  operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *) 0 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_NumTypes___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  result = (int)((operations_research::RoutingModel::VehicleTypeContainer const *)arg1)->NumTypes();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_Type___(void * jarg1, int jarg2) {
  int jresult ;
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int)((operations_research::RoutingModel::VehicleTypeContainer const *)arg1)->Type(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_type_index_of_vehicle_set___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  std::vector< int > *arg2 = (std::vector< int > *) 0 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  arg2 = (std::vector< int > *)jarg2; 
  if (arg1) (arg1)->type_index_of_vehicle = *arg2;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_type_index_of_vehicle_get___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  result = (std::vector< int > *)& ((arg1)->type_index_of_vehicle);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_sorted_vehicle_classes_per_type_set___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  std::vector< std::set< operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry > > *arg2 = (std::vector< std::set< operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry > > *) 0 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  arg2 = (std::vector< std::set< operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry > > *)jarg2; 
  if (arg1) (arg1)->sorted_vehicle_classes_per_type = *arg2;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_sorted_vehicle_classes_per_type_get___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  std::vector< std::set< operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry > > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  result = (std::vector< std::set< operations_research::RoutingModel::VehicleTypeContainer::VehicleClassEntry > > *)& ((arg1)->sorted_vehicle_classes_per_type);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_vehicles_per_vehicle_class_set___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  std::vector< std::deque< int > > *arg2 = (std::vector< std::deque< int > > *) 0 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  arg2 = (std::vector< std::deque< int > > *)jarg2; 
  if (arg1) (arg1)->vehicles_per_vehicle_class = *arg2;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleTypeContainer_vehicles_per_vehicle_class_get___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  std::vector< std::deque< int > > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  result = (std::vector< std::deque< int > > *)& ((arg1)->vehicles_per_vehicle_class);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RoutingModel_VehicleTypeContainer___() {
  void * jresult ;
  operations_research::RoutingModel::VehicleTypeContainer *result = 0 ;
  
  result = (operations_research::RoutingModel::VehicleTypeContainer *)new operations_research::RoutingModel::VehicleTypeContainer();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RoutingModel_VehicleTypeContainer___(void * jarg1) {
  operations_research::RoutingModel::VehicleTypeContainer *arg1 = (operations_research::RoutingModel::VehicleTypeContainer *) 0 ;
  
  arg1 = (operations_research::RoutingModel::VehicleTypeContainer *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_kNoPenalty_get___() {
  long long jresult ;
  int64_t result;
  
  result = (int64_t)(int64_t)operations_research::RoutingModel::kNoPenalty;
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_kNoDisjunction_get___() {
  int jresult ;
  operations_research::RoutingModel::DisjunctionIndex result;
  
  result = (operations_research::RoutingModel::DisjunctionIndex)operations_research::RoutingModel::kNoDisjunction;
  {
    jresult = (&result)->value();
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_kNoDimension_get___() {
  int jresult ;
  operations_research::RoutingModel::DimensionIndex result;
  
  result = (operations_research::RoutingModel::DimensionIndex)operations_research::RoutingModel::kNoDimension;
  {
    jresult = (&result)->value();
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RoutingModel__SWIG_0___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingIndexManager *arg1 = 0 ;
  operations_research::RoutingModel *result = 0 ;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::RoutingIndexManager const & type is null", 0);
    return 0;
  } 
  result = (operations_research::RoutingModel *)new operations_research::RoutingModel((operations_research::RoutingIndexManager const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RoutingModel__SWIG_1___(void * jarg1, int parameters_size, uint8_t* jarg2) {
  void * jresult ;
  operations_research::RoutingIndexManager *arg1 = 0 ;
  operations_research::RoutingModelParameters *arg2 = 0 ;
  operations_research::RoutingModel *result = 0 ;
  
  arg1 = (operations_research::RoutingIndexManager *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::RoutingIndexManager const & type is null", 0);
    return 0;
  } 
  {
    arg2 = new operations_research::RoutingModelParameters;
    bool parsed_ok = arg2->ParseFromArray(jarg2, parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingModelParameters protocol message.");
    }
  }
  result = (operations_research::RoutingModel *)new operations_research::RoutingModel((operations_research::RoutingIndexManager const &)*arg1,(operations_research::RoutingModelParameters const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2;
  }
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RoutingModel___(void * jarg1) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_RegisterUnaryTransitVector___(void * jarg1,  int length2, int64_t*  jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  (&arg2)->clear();
  (&arg2)->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    (&arg2)->emplace_back(jarg2[i]);
  }
  
  result = (int)(arg1)->RegisterUnaryTransitVector(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_RegisterUnaryTransitCallback___(void * jarg1,  void *  jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::TransitCallback1 arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = [jarg2](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg2)(t);
  };
  
  result = (int)(arg1)->RegisterUnaryTransitCallback(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_RegisterPositiveUnaryTransitCallback___(void * jarg1,  void *  jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::TransitCallback1 arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = [jarg2](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg2)(t);
  };
  
  result = (int)(arg1)->RegisterPositiveUnaryTransitCallback(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_RegisterTransitMatrix___(void * jarg1, 
  int len2_1, int len2_2[], int64_t*
  jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< std::vector< int64_t > > arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  (&arg2)->clear();
  (&arg2)->resize(len2_1);
  
  int64_t* inner_array = reinterpret_cast<int64_t*>(jarg2);
  int actualIndex = 0;
  for (int index1 = 0; index1 < len2_1; ++index1) {
    arg2[index1].reserve(len2_2[index1]);
    for (int index2 = 0; index2 < len2_2[index1]; ++index2) {
      const int64_t value = inner_array[actualIndex];
      arg2[index1].emplace_back(value);
      actualIndex++;
    }
  }
  
  result = (int)(arg1)->RegisterTransitMatrix(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_RegisterTransitCallback___(void * jarg1,  void *  jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::TransitCallback2 arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = [jarg2](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg2)(t, u);
  };
  
  result = (int)(arg1)->RegisterTransitCallback(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_RegisterPositiveTransitCallback___(void * jarg1,  void *  jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::TransitCallback2 arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = [jarg2](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg2)(t, u);
  };
  
  result = (int)(arg1)->RegisterPositiveTransitCallback(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddDimension___(void * jarg1, int jarg2, long long jarg3, long long jarg4, unsigned int jarg5, char * jarg6) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  bool arg5 ;
  std::string *arg6 = 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = jarg5 ? true : false; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  result = (bool)(arg1)->AddDimension(arg2,arg3,arg4,arg5,(std::string const &)*arg6);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddDimensionWithVehicleTransits___(void * jarg1,  int length2, int*  jarg2, long long jarg3, long long jarg4, unsigned int jarg5, char * jarg6) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int > *arg2 = 0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  bool arg5 ;
  std::string *arg6 = 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = jarg5 ? true : false; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  result = (bool)(arg1)->AddDimensionWithVehicleTransits((std::vector< int > const &)*arg2,arg3,arg4,arg5,(std::string const &)*arg6);
  jresult = result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddDimensionWithVehicleCapacity___(void * jarg1, int jarg2, long long jarg3,  int length4, int64_t*  jarg4, unsigned int jarg5, char * jarg6) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int64_t arg3 ;
  std::vector< int64_t > arg4 ;
  bool arg5 ;
  std::string *arg6 = 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int64_t)jarg3; 
  
  (&arg4)->clear();
  (&arg4)->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    (&arg4)->emplace_back(jarg4[i]);
  }
  
  arg5 = jarg5 ? true : false; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  result = (bool)(arg1)->AddDimensionWithVehicleCapacity(arg2,arg3,arg4,arg5,(std::string const &)*arg6);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddDimensionWithVehicleTransitAndCapacity___(void * jarg1,  int length2, int*  jarg2, long long jarg3,  int length4, int64_t*  jarg4, unsigned int jarg5, char * jarg6) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int > *arg2 = 0 ;
  int64_t arg3 ;
  std::vector< int64_t > arg4 ;
  bool arg5 ;
  std::string *arg6 = 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (int64_t)jarg3; 
  
  (&arg4)->clear();
  (&arg4)->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    (&arg4)->emplace_back(jarg4[i]);
  }
  
  arg5 = jarg5 ? true : false; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  result = (bool)(arg1)->AddDimensionWithVehicleTransitAndCapacity((std::vector< int > const &)*arg2,arg3,arg4,arg5,(std::string const &)*arg6);
  jresult = result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddConstantDimensionWithSlack___(void * jarg1, long long jarg2, long long jarg3, long long jarg4, unsigned int jarg5, char * jarg6) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  bool arg5 ;
  std::string *arg6 = 0 ;
  std::pair< int,bool > result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  arg5 = jarg5 ? true : false; 
  if (!jarg6) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg6_str(jarg6);
  arg6 = &arg6_str; 
  result = (arg1)->AddConstantDimensionWithSlack(arg2,arg3,arg4,arg5,(std::string const &)*arg6);
  jresult = new std::pair< int,bool >((const std::pair< int,bool > &)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddConstantDimension___(void * jarg1, long long jarg2, long long jarg3, unsigned int jarg4, char * jarg5) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  bool arg4 ;
  std::string *arg5 = 0 ;
  std::pair< int,bool > result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = jarg4 ? true : false; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (arg1)->AddConstantDimension(arg2,arg3,arg4,(std::string const &)*arg5);
  jresult = new std::pair< int,bool >((const std::pair< int,bool > &)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddVectorDimension___(void * jarg1,  int length2, int64_t*  jarg2, long long jarg3, unsigned int jarg4, char * jarg5) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > arg2 ;
  int64_t arg3 ;
  bool arg4 ;
  std::string *arg5 = 0 ;
  std::pair< int,bool > result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  (&arg2)->clear();
  (&arg2)->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    (&arg2)->emplace_back(jarg2[i]);
  }
  
  arg3 = (int64_t)jarg3; 
  arg4 = jarg4 ? true : false; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (arg1)->AddVectorDimension(arg2,arg3,arg4,(std::string const &)*arg5);
  jresult = new std::pair< int,bool >((const std::pair< int,bool > &)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddMatrixDimension___(void * jarg1, 
  int len2_1, int len2_2[], int64_t*
  jarg2, long long jarg3, unsigned int jarg4, char * jarg5) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< std::vector< int64_t > > arg2 ;
  int64_t arg3 ;
  bool arg4 ;
  std::string *arg5 = 0 ;
  std::pair< int,bool > result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  (&arg2)->clear();
  (&arg2)->resize(len2_1);
  
  int64_t* inner_array = reinterpret_cast<int64_t*>(jarg2);
  int actualIndex = 0;
  for (int index1 = 0; index1 < len2_1; ++index1) {
    arg2[index1].reserve(len2_2[index1]);
    for (int index2 = 0; index2 < len2_2[index1]; ++index2) {
      const int64_t value = inner_array[actualIndex];
      arg2[index1].emplace_back(value);
      actualIndex++;
    }
  }
  
  arg3 = (int64_t)jarg3; 
  arg4 = jarg4 ? true : false; 
  if (!jarg5) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg5_str(jarg5);
  arg5 = &arg5_str; 
  result = (arg1)->AddMatrixDimension(arg2,arg3,arg4,(std::string const &)*arg5);
  jresult = new std::pair< int,bool >((const std::pair< int,bool > &)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_MakePathSpansAndTotalSlacks___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingDimension *arg2 = (operations_research::RoutingDimension *) 0 ;
  std::vector< operations_research::IntVar * > arg3 ;
  std::vector< operations_research::IntVar * > arg4 ;
  std::vector< operations_research::IntVar * > *argp3 ;
  std::vector< operations_research::IntVar * > *argp4 ;
  operations_research::Constraint *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::RoutingDimension *)jarg2; 
  argp3 = (std::vector< operations_research::IntVar * > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::IntVar * >", 0);
    return 0;
  }
  arg3 = *argp3; 
  argp4 = (std::vector< operations_research::IntVar * > *)jarg4; 
  if (!argp4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::IntVar * >", 0);
    return 0;
  }
  arg4 = *argp4; 
  result = (operations_research::Constraint *)(arg1)->MakePathSpansAndTotalSlacks((operations_research::RoutingDimension const *)arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetGlobalDimensionCumulMPOptimizers___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< std::unique_ptr< operations_research::GlobalDimensionCumulOptimizer > > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (std::vector< std::unique_ptr< operations_research::GlobalDimensionCumulOptimizer > > *) &((operations_research::RoutingModel const *)arg1)->GetGlobalDimensionCumulMPOptimizers();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetMutableGlobalCumulMPOptimizer___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingDimension *arg2 = 0 ;
  operations_research::GlobalDimensionCumulOptimizer *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::RoutingDimension *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::RoutingDimension const & type is null", 0);
    return 0;
  } 
  result = (operations_research::GlobalDimensionCumulOptimizer *)((operations_research::RoutingModel const *)arg1)->GetMutableGlobalCumulMPOptimizer((operations_research::RoutingDimension const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_HasDimension___(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->HasDimension((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetDimensionOrDie___(void * jarg1, char * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::RoutingDimension *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (operations_research::RoutingDimension *) &((operations_research::RoutingModel const *)arg1)->GetDimensionOrDie((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetMutableDimension___(void * jarg1, char * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::RoutingDimension *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (operations_research::RoutingDimension *)((operations_research::RoutingModel const *)arg1)->GetMutableDimension((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetPrimaryConstrainedDimension___(void * jarg1, char * jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->SetPrimaryConstrainedDimension((std::string const &)*arg2);
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetPrimaryConstrainedDimension___(void * jarg1) {
  char * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (std::string *) &((operations_research::RoutingModel const *)arg1)->GetPrimaryConstrainedDimension();
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetDimensionResourceGroupIndices___(void * jarg1, void * jarg2) {
  void* jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingDimension *arg2 = (operations_research::RoutingDimension *) 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::RoutingDimension *)jarg2; 
  result = (std::vector< int > *) &((operations_research::RoutingModel const *)arg1)->GetDimensionResourceGroupIndices((operations_research::RoutingDimension const *)arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddDisjunction__SWIG_0___(void * jarg1,  int length2, int64_t*  jarg2, long long jarg3, long long jarg4) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  int64_t arg3 ;
  int64_t arg4 ;
  operations_research::RoutingModel::DisjunctionIndex result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (arg1)->AddDisjunction((std::vector< int64_t > const &)*arg2,arg3,arg4);
  {
    jresult = (&result)->value();
  }
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddDisjunction__SWIG_1___(void * jarg1,  int length2, int64_t*  jarg2, long long jarg3) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  int64_t arg3 ;
  operations_research::RoutingModel::DisjunctionIndex result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (int64_t)jarg3; 
  result = (arg1)->AddDisjunction((std::vector< int64_t > const &)*arg2,arg3);
  {
    jresult = (&result)->value();
  }
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddDisjunction__SWIG_2___(void * jarg1,  int length2, int64_t*  jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::RoutingModel::DisjunctionIndex result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (arg1)->AddDisjunction((std::vector< int64_t > const &)*arg2);
  {
    jresult = (&result)->value();
  }
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetDisjunctionIndices___(void * jarg1, long long jarg2) {
  void* jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  std::vector< operations_research::RoutingModel::DisjunctionIndex > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (std::vector< operations_research::RoutingModel::DisjunctionIndex > *) &((operations_research::RoutingModel const *)arg1)->GetDisjunctionIndices(arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetDisjunctionNodeIndices___(void * jarg1, int jarg2) {
  void* jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::DisjunctionIndex arg2 ;
  std::vector< int64_t > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = operations_research::RoutingDisjunctionIndex(jarg2);
  }
  result = (std::vector< int64_t > *) &((operations_research::RoutingModel const *)arg1)->GetDisjunctionNodeIndices(arg2);
  
  jresult = new std::vector< int64_t >((const std::vector< int64_t> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetDisjunctionPenalty___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::DisjunctionIndex arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = operations_research::RoutingDisjunctionIndex(jarg2);
  }
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetDisjunctionPenalty(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetDisjunctionMaxCardinality___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::DisjunctionIndex arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = operations_research::RoutingDisjunctionIndex(jarg2);
  }
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetDisjunctionMaxCardinality(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetNumberOfDisjunctions___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->GetNumberOfDisjunctions();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero___(void * jarg1) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  (arg1)->IgnoreDisjunctionsAlreadyForcedToZero();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddSoftSameVehicleConstraint___(void * jarg1,  int length2, int64_t*  jarg2, long long jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (int64_t)jarg3; 
  (arg1)->AddSoftSameVehicleConstraint((std::vector< int64_t > const &)*arg2,arg3);
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetAllowedVehiclesForIndex___(void * jarg1,  int length2, int*  jarg2, long long jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int > *arg2 = 0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = new std::vector<int>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  arg3 = (int64_t)jarg3; 
  (arg1)->SetAllowedVehiclesForIndex((std::vector< int > const &)*arg2,arg3);
  {
    delete arg2; 
  }
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_IsVehicleAllowedForIndex___(void * jarg1, int jarg2, long long jarg3) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int64_t arg3 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (bool)(arg1)->IsVehicleAllowedForIndex(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddPickupAndDelivery___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->AddPickupAndDelivery(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddPickupAndDeliverySets___(void * jarg1, int jarg2, int jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::DisjunctionIndex arg2 ;
  operations_research::RoutingModel::DisjunctionIndex arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = operations_research::RoutingDisjunctionIndex(jarg2);
  }
  {
    arg3 = operations_research::RoutingDisjunctionIndex(jarg3);
  }
  (arg1)->AddPickupAndDeliverySets(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles___(void * jarg1, int jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::PickupAndDeliveryPolicy arg2 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::RoutingModel::PickupAndDeliveryPolicy)jarg2; 
  (arg1)->SetPickupAndDeliveryPolicyOfAllVehicles(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetPickupAndDeliveryPolicyOfVehicle___(void * jarg1, int jarg2, int jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::PickupAndDeliveryPolicy arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::RoutingModel::PickupAndDeliveryPolicy)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->SetPickupAndDeliveryPolicyOfVehicle(arg2,arg3);
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetPickupAndDeliveryPolicyOfVehicle___(void * jarg1, int jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  operations_research::RoutingModel::PickupAndDeliveryPolicy result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::RoutingModel::PickupAndDeliveryPolicy)((operations_research::RoutingModel const *)arg1)->GetPickupAndDeliveryPolicyOfVehicle(arg2);
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetNumOfSingletonNodes___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->GetNumOfSingletonNodes();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_TYPE_ADDED_TO_VEHICLE_get___() {
  int jresult ;
  operations_research::RoutingModel::VisitTypePolicy result;
  
  result = (operations_research::RoutingModel::VisitTypePolicy)operations_research::RoutingModel::TYPE_ADDED_TO_VEHICLE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ADDED_TYPE_REMOVED_FROM_VEHICLE_get___() {
  int jresult ;
  operations_research::RoutingModel::VisitTypePolicy result;
  
  result = (operations_research::RoutingModel::VisitTypePolicy)operations_research::RoutingModel::ADDED_TYPE_REMOVED_FROM_VEHICLE;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_TYPE_ON_VEHICLE_UP_TO_VISIT_get___() {
  int jresult ;
  operations_research::RoutingModel::VisitTypePolicy result;
  
  result = (operations_research::RoutingModel::VisitTypePolicy)operations_research::RoutingModel::TYPE_ON_VEHICLE_UP_TO_VISIT;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED_get___() {
  int jresult ;
  operations_research::RoutingModel::VisitTypePolicy result;
  
  result = (operations_research::RoutingModel::VisitTypePolicy)operations_research::RoutingModel::TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED;
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetVisitType___(void * jarg1, long long jarg2, int jarg3, int jarg4) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int arg3 ;
  operations_research::RoutingModel::VisitTypePolicy arg4 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (operations_research::RoutingModel::VisitTypePolicy)jarg4; 
  (arg1)->SetVisitType(arg2,arg3,arg4);
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetVisitType___(void * jarg1, long long jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int)((operations_research::RoutingModel const *)arg1)->GetVisitType(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetSingleNodesOfType___(void * jarg1, int jarg2) {
  void* jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (std::vector< int > *) &((operations_research::RoutingModel const *)arg1)->GetSingleNodesOfType(arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetPairIndicesOfType___(void * jarg1, int jarg2) {
  void* jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (std::vector< int > *) &((operations_research::RoutingModel const *)arg1)->GetPairIndicesOfType(arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetVisitTypePolicy___(void * jarg1, long long jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  operations_research::RoutingModel::VisitTypePolicy result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::RoutingModel::VisitTypePolicy)((operations_research::RoutingModel const *)arg1)->GetVisitTypePolicy(arg2);
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_CloseVisitTypes___(void * jarg1) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  (arg1)->CloseVisitTypes();
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetNumberOfVisitTypes___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->GetNumberOfVisitTypes();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddHardTypeIncompatibility___(void * jarg1, int jarg2, int jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->AddHardTypeIncompatibility(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddTemporalTypeIncompatibility___(void * jarg1, int jarg2, int jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->AddTemporalTypeIncompatibility(arg2,arg3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetTemporalTypeIncompatibilitiesOfType___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  absl::flat_hash_set< int > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (absl::flat_hash_set< int > *) &((operations_research::RoutingModel const *)arg1)->GetTemporalTypeIncompatibilitiesOfType(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_HasHardTypeIncompatibilities___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->HasHardTypeIncompatibilities();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_HasTemporalTypeIncompatibilities___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->HasTemporalTypeIncompatibilities();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddRequiredTypeAlternativesWhenAddingType___(void * jarg1, int jarg2, void * jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  absl::flat_hash_set< int > arg3 ;
  absl::flat_hash_set< int > *argp3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  argp3 = (absl::flat_hash_set< int > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null absl::flat_hash_set< int >", 0);
    return ;
  }
  arg3 = *argp3; 
  (arg1)->AddRequiredTypeAlternativesWhenAddingType(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddRequiredTypeAlternativesWhenRemovingType___(void * jarg1, int jarg2, void * jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  absl::flat_hash_set< int > arg3 ;
  absl::flat_hash_set< int > *argp3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  argp3 = (absl::flat_hash_set< int > *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null absl::flat_hash_set< int >", 0);
    return ;
  }
  arg3 = *argp3; 
  (arg1)->AddRequiredTypeAlternativesWhenRemovingType(arg2,arg3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  std::vector< absl::flat_hash_set< int > > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (std::vector< absl::flat_hash_set< int > > *) &((operations_research::RoutingModel const *)arg1)->GetSameVehicleRequiredTypeAlternativesOfType(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetRequiredTypeAlternativesWhenAddingType___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  std::vector< absl::flat_hash_set< int > > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (std::vector< absl::flat_hash_set< int > > *) &((operations_research::RoutingModel const *)arg1)->GetRequiredTypeAlternativesWhenAddingType(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetRequiredTypeAlternativesWhenRemovingType___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  std::vector< absl::flat_hash_set< int > > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (std::vector< absl::flat_hash_set< int > > *) &((operations_research::RoutingModel const *)arg1)->GetRequiredTypeAlternativesWhenRemovingType(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_HasSameVehicleTypeRequirements___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->HasSameVehicleTypeRequirements();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_HasTemporalTypeRequirements___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->HasTemporalTypeRequirements();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_UnperformedPenalty___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->UnperformedPenalty(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_UnperformedPenaltyOrValue___(void * jarg1, long long jarg2, long long jarg3) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->UnperformedPenaltyOrValue(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetDepot___(void * jarg1) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetDepot();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetMaximumNumberOfActiveVehicles___(void * jarg1, int jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->SetMaximumNumberOfActiveVehicles(arg2);
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetMaximumNumberOfActiveVehicles___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->GetMaximumNumberOfActiveVehicles();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetArcCostEvaluatorOfAllVehicles___(void * jarg1, int jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  (arg1)->SetArcCostEvaluatorOfAllVehicles(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetArcCostEvaluatorOfVehicle___(void * jarg1, int jarg2, int jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->SetArcCostEvaluatorOfVehicle(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetFixedCostOfAllVehicles___(void * jarg1, long long jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetFixedCostOfAllVehicles(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetFixedCostOfVehicle___(void * jarg1, long long jarg2, int jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->SetFixedCostOfVehicle(arg2,arg3);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetFixedCostOfVehicle___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetFixedCostOfVehicle(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetAmortizedCostFactorsOfAllVehicles___(void * jarg1, long long jarg2, long long jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->SetAmortizedCostFactorsOfAllVehicles(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetAmortizedCostFactorsOfVehicle___(void * jarg1, long long jarg2, long long jarg3, int jarg4) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int arg4 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int)jarg4; 
  (arg1)->SetAmortizedCostFactorsOfVehicle(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetAmortizedLinearCostFactorOfVehicles___(void * jarg1) {
  void* jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (std::vector< int64_t > *) &((operations_research::RoutingModel const *)arg1)->GetAmortizedLinearCostFactorOfVehicles();
  
  jresult = new std::vector< int64_t >((const std::vector< int64_t> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles___(void * jarg1) {
  void* jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (std::vector< int64_t > *) &((operations_research::RoutingModel const *)arg1)->GetAmortizedQuadraticCostFactorOfVehicles();
  
  jresult = new std::vector< int64_t >((const std::vector< int64_t> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ConsiderEmptyRouteCostsForVehicle___(void * jarg1, unsigned int jarg2, int jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  bool arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = jarg2 ? true : false; 
  arg3 = (int)jarg3; 
  (arg1)->ConsiderEmptyRouteCostsForVehicle(arg2,arg3);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AreEmptyRouteCostsConsideredForVehicle___(void * jarg1, int jarg2) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->AreEmptyRouteCostsConsideredForVehicle(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetFirstSolutionEvaluator___(void * jarg1,  void *  jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Solver::IndexEvaluator2 arg2 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = [jarg2](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg2)(t, u);
  };
  
  (arg1)->SetFirstSolutionEvaluator(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddLocalSearchOperator___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::LocalSearchOperator *arg2 = (operations_research::LocalSearchOperator *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::LocalSearchOperator *)jarg2; 
  (arg1)->AddLocalSearchOperator(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddSearchMonitor___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::SearchMonitor *arg2 = (operations_research::SearchMonitor *) (operations_research::SearchMonitor *)0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::SearchMonitor *)jarg2; 
  (arg1)->AddSearchMonitor(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddAtSolutionCallback___(void * jarg1,  void *  jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::function< void () > arg2 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = [jarg2]() -> void {
    return (*(void(*)())jarg2)();
  };
  
  (arg1)->AddAtSolutionCallback(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddVariableMinimizedByFinalizer___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->AddVariableMinimizedByFinalizer(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddVariableMaximizedByFinalizer___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->AddVariableMaximizedByFinalizer(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddWeightedVariableMinimizedByFinalizer___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->AddWeightedVariableMinimizedByFinalizer(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddVariableTargetToFinalizer___(void * jarg1, void * jarg2, long long jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) 0 ;
  int64_t arg3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  arg3 = (int64_t)jarg3; 
  (arg1)->AddVariableTargetToFinalizer(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_CloseModel___(void * jarg1) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  (arg1)->CloseModel();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_CloseModelWithParameters___(void * jarg1, int search_parameters_size, uint8_t* jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingSearchParameters *arg2 = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg2->ParseFromArray(jarg2, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  (arg1)->CloseModelWithParameters((operations_research::RoutingSearchParameters const &)*arg2);
  {
    delete arg2;
  }
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_Solve__SWIG_0___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  result = (operations_research::Assignment *)(arg1)->Solve((operations_research::Assignment const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_Solve__SWIG_1___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (operations_research::Assignment *)(arg1)->Solve();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SolveWithParameters___(void * jarg1, int search_parameters_size, uint8_t* jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingSearchParameters *arg2 = 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg2->ParseFromArray(jarg2, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  result = (operations_research::Assignment *)(arg1)->SolveWithParameters((operations_research::RoutingSearchParameters const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2;
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SolveFromAssignmentWithParameters___(void * jarg1, void * jarg2, int search_parameters_size, uint8_t* jarg3) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::RoutingSearchParameters *arg3 = 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  {
    arg3 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg3->ParseFromArray(jarg3, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  result = (operations_research::Assignment *)(arg1)->SolveFromAssignmentWithParameters((operations_research::Assignment const *)arg2,(operations_research::RoutingSearchParameters const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3;
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SolveFromAssignmentsWithParameters__SWIG_0___(void * jarg1, void * jarg2, int search_parameters_size, uint8_t* jarg3, void * jarg4) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< operations_research::Assignment const * > *arg2 = 0 ;
  operations_research::RoutingSearchParameters *arg3 = 0 ;
  std::vector< operations_research::Assignment const * > *arg4 = (std::vector< operations_research::Assignment const * > *) 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (std::vector< operations_research::Assignment const * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::Assignment const * > const & type is null", 0);
    return 0;
  } 
  {
    arg3 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg3->ParseFromArray(jarg3, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  arg4 = (std::vector< operations_research::Assignment const * > *)jarg4; 
  result = (operations_research::Assignment *)(arg1)->SolveFromAssignmentsWithParameters((std::vector< operations_research::Assignment const * > const &)*arg2,(operations_research::RoutingSearchParameters const &)*arg3,arg4);
  jresult = (void *)result; 
  {
    delete arg3;
  }
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SolveFromAssignmentsWithParameters__SWIG_1___(void * jarg1, void * jarg2, int search_parameters_size, uint8_t* jarg3) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< operations_research::Assignment const * > *arg2 = 0 ;
  operations_research::RoutingSearchParameters *arg3 = 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (std::vector< operations_research::Assignment const * > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< operations_research::Assignment const * > const & type is null", 0);
    return 0;
  } 
  {
    arg3 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg3->ParseFromArray(jarg3, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  result = (operations_research::Assignment *)(arg1)->SolveFromAssignmentsWithParameters((std::vector< operations_research::Assignment const * > const &)*arg2,(operations_research::RoutingSearchParameters const &)*arg3);
  jresult = (void *)result; 
  {
    delete arg3;
  }
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_SetAssignmentFromOtherModelAssignment___(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = (operations_research::Assignment *) 0 ;
  operations_research::RoutingModel *arg3 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg4 = (operations_research::Assignment *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2; 
  arg3 = (operations_research::RoutingModel *)jarg3; 
  arg4 = (operations_research::Assignment *)jarg4; 
  (arg1)->SetAssignmentFromOtherModelAssignment(arg2,(operations_research::RoutingModel const *)arg3,(operations_research::Assignment const *)arg4);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ComputeLowerBound___(void * jarg1) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int64_t)(arg1)->ComputeLowerBound();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetStatus___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::Status result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (operations_research::RoutingModel::Status)((operations_research::RoutingModel const *)arg1)->status();
  jresult = (int)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ApplyLocks___(void * jarg1,  int length2, int64_t*  jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< int64_t > *arg2 = 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  arg2 = new std::vector<int64_t>;
  arg2->reserve(length2);
  for(int i = 0; i < length2; ++i) {
    arg2->emplace_back(jarg2[i]);
  }
  
  result = (operations_research::IntVar *)(arg1)->ApplyLocks((std::vector< int64_t > const &)*arg2);
  jresult = (void *)result; 
  {
    delete arg2; 
  }
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ApplyLocksToAllVehicles___(void * jarg1, 
  int len2_1, int len2_2[], int64_t*
  jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< std::vector< int64_t > > *arg2 = 0 ;
  bool arg3 ;
  std::vector< std::vector< int64_t > > result2 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  result2.clear();
  result2.resize(len2_1);
  
  int64_t* inner_array = reinterpret_cast<int64_t*>(jarg2);
  int actualIndex = 0;
  for (int index1 = 0; index1 < len2_1; ++index1) {
    result2[index1].reserve(len2_2[index1]);
    for (int index2 = 0; index2 < len2_2[index1]; ++index2) {
      const int64_t value = inner_array[actualIndex];
      result2[index1].emplace_back(value);
      actualIndex++;
    }
  }
  
  arg2 = &result2;
  
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->ApplyLocksToAllVehicles((std::vector< std::vector< int64_t > > const &)*arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_PreAssignment___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (operations_research::Assignment *)((operations_research::RoutingModel const *)arg1)->PreAssignment();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_MutablePreAssignment___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (operations_research::Assignment *)(arg1)->MutablePreAssignment();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_WriteAssignment___(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->WriteAssignment((std::string const &)*arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ReadAssignment___(void * jarg1, char * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::string *arg2 = 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (operations_research::Assignment *)(arg1)->ReadAssignment((std::string const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_RestoreAssignment___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::Assignment const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Assignment *)(arg1)->RestoreAssignment((operations_research::Assignment const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ReadAssignmentFromRoutes___(void * jarg1, 
  int len2_1, int len2_2[], int64_t*
  jarg2, unsigned int jarg3) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< std::vector< int64_t > > *arg2 = 0 ;
  bool arg3 ;
  std::vector< std::vector< int64_t > > result2 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  result2.clear();
  result2.resize(len2_1);
  
  int64_t* inner_array = reinterpret_cast<int64_t*>(jarg2);
  int actualIndex = 0;
  for (int index1 = 0; index1 < len2_1; ++index1) {
    result2[index1].reserve(len2_2[index1]);
    for (int index2 = 0; index2 < len2_2[index1]; ++index2) {
      const int64_t value = inner_array[actualIndex];
      result2[index1].emplace_back(value);
      actualIndex++;
    }
  }
  
  arg2 = &result2;
  
  arg3 = jarg3 ? true : false; 
  result = (operations_research::Assignment *)(arg1)->ReadAssignmentFromRoutes((std::vector< std::vector< int64_t > > const &)*arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_RoutesToAssignment___(void * jarg1, 
  int len2_1, int len2_2[], int64_t*
  jarg2, unsigned int jarg3, unsigned int jarg4, void * jarg5) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< std::vector< int64_t > > *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  operations_research::Assignment *arg5 = (operations_research::Assignment *) (operations_research::Assignment *)0 ;
  std::vector< std::vector< int64_t > > result2 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  
  result2.clear();
  result2.resize(len2_1);
  
  int64_t* inner_array = reinterpret_cast<int64_t*>(jarg2);
  int actualIndex = 0;
  for (int index1 = 0; index1 < len2_1; ++index1) {
    result2[index1].reserve(len2_2[index1]);
    for (int index2 = 0; index2 < len2_2[index1]; ++index2) {
      const int64_t value = inner_array[actualIndex];
      result2[index1].emplace_back(value);
      actualIndex++;
    }
  }
  
  arg2 = &result2;
  
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  arg5 = (operations_research::Assignment *)jarg5; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->RoutesToAssignment((std::vector< std::vector< int64_t > > const &)*arg2,arg3,arg4,arg5);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AssignmentToRoutes___(void * jarg1, void * jarg2, 
  int len3_1, int len3_2[], int64_t*
  jarg3) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = 0 ;
  std::vector< std::vector< int64_t > > *arg3 = (std::vector< std::vector< int64_t > > *) (std::vector< std::vector< int64_t > > *)0 ;
  std::vector< std::vector< int64_t > > result3 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::Assignment const & type is null", 0);
    return ;
  } 
  
  result3.clear();
  result3.resize(len3_1);
  
  int64_t* flat_array = reinterpret_cast<int64_t*>(jarg3);
  int actualIndex = 0;
  for (int index1 = 0; index1 < len3_1; ++index1) {
    result3[index1].reserve(len3_2[index1]);
    for (int index2 = 0; index2 < len3_2[index1]; ++index2) {
      const int64_t value = flat_array[actualIndex];
      result3[index1].emplace_back(value);
      actualIndex++;
    }
  }
  arg3 = &result3;
  
  ((operations_research::RoutingModel const *)arg1)->AssignmentToRoutes((operations_research::Assignment const &)*arg2,arg3);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_CompactAssignment___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::Assignment const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Assignment *)((operations_research::RoutingModel const *)arg1)->CompactAssignment((operations_research::Assignment const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_CompactAndCheckAssignment___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = 0 ;
  operations_research::Assignment *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::Assignment const & type is null", 0);
    return 0;
  } 
  result = (operations_research::Assignment *)((operations_research::RoutingModel const *)arg1)->CompactAndCheckAssignment((operations_research::Assignment const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddToAssignment___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::IntVar *arg2 = (operations_research::IntVar *) (operations_research::IntVar *)0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::IntVar *)jarg2; 
  (arg1)->AddToAssignment(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddIntervalToAssignment___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::IntervalVar *arg2 = (operations_research::IntervalVar *) (operations_research::IntervalVar *)0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::IntervalVar *)jarg2; 
  (arg1)->AddIntervalToAssignment(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_AddLocalSearchFilter___(void * jarg1, void * jarg2) {
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::LocalSearchFilter *arg2 = (operations_research::LocalSearchFilter *) 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::LocalSearchFilter *)jarg2; 
  (arg1)->AddLocalSearchFilter(arg2);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_Start___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->Start(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_End___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->End(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_IsStart___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->IsStart(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_IsEnd___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->IsEnd(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleIndex___(void * jarg1, long long jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int)((operations_research::RoutingModel const *)arg1)->VehicleIndex(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_Next___(void * jarg1, void * jarg2, long long jarg3) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = 0 ;
  int64_t arg3 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::Assignment const & type is null", 0);
    return 0;
  } 
  arg3 = (int64_t)jarg3; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->Next((operations_research::Assignment const &)*arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_IsVehicleUsed___(void * jarg1, void * jarg2, int jarg3) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = 0 ;
  int arg3 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::Assignment const & type is null", 0);
    return 0;
  } 
  arg3 = (int)jarg3; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->IsVehicleUsed((operations_research::Assignment const &)*arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_Nexts___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (std::vector< operations_research::IntVar * > *) &((operations_research::RoutingModel const *)arg1)->Nexts();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleVars___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (std::vector< operations_research::IntVar * > *) &((operations_research::RoutingModel const *)arg1)->VehicleVars();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_NextVar___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingModel const *)arg1)->NextVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ActiveVar___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingModel const *)arg1)->ActiveVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ActiveVehicleVar___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingModel const *)arg1)->ActiveVehicleVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleCostsConsideredVar___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingModel const *)arg1)->VehicleCostsConsideredVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_VehicleVar___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingModel const *)arg1)->VehicleVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_CostVar___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (operations_research::IntVar *)((operations_research::RoutingModel const *)arg1)->CostVar();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetArcCostForVehicle___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetArcCostForVehicle(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_CostsAreHomogeneousAcrossVehicles___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->CostsAreHomogeneousAcrossVehicles();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetHomogeneousCost___(void * jarg1, long long jarg2, long long jarg3) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetHomogeneousCost(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetArcCostForFirstSolution___(void * jarg1, long long jarg2, long long jarg3) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetArcCostForFirstSolution(arg2,arg3);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetArcCostForClass___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetArcCostForClass(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetCostClassIndexOfVehicle___(void * jarg1, long long jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  operations_research::RoutingModel::CostClassIndex result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = ((operations_research::RoutingModel const *)arg1)->GetCostClassIndexOfVehicle(arg2);
  {
    jresult = (&result)->value();
  }
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_HasVehicleWithCostClassIndex___(void * jarg1, int jarg2) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::CostClassIndex arg2 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = operations_research::RoutingCostClassIndex(jarg2);
  }
  result = (bool)((operations_research::RoutingModel const *)arg1)->HasVehicleWithCostClassIndex(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetCostClassesCount___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->GetCostClassesCount();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetNonZeroCostClassesCount___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->GetNonZeroCostClassesCount();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetVehicleClassIndexOfVehicle___(void * jarg1, long long jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  operations_research::RoutingModel::VehicleClassIndex result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = ((operations_research::RoutingModel const *)arg1)->GetVehicleClassIndexOfVehicle(arg2);
  {
    jresult = (&result)->value();
  }
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetVehicleOfClass___(void * jarg1, int jarg2) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::VehicleClassIndex arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = operations_research::RoutingVehicleClassIndex(jarg2);
  }
  result = (int)((operations_research::RoutingModel const *)arg1)->GetVehicleOfClass(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetVehicleClassesCount___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->GetVehicleClassesCount();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void* SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetSameVehicleIndicesOfIndex___(void * jarg1, int jarg2) {
  void* jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int arg2 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int)jarg2; 
  result = (std::vector< int > *) &((operations_research::RoutingModel const *)arg1)->GetSameVehicleIndicesOfIndex(arg2);
  
  jresult = new std::vector< int >((const std::vector< int> &)*result);
  
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetVehicleTypeContainer___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingModel::VehicleTypeContainer *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (operations_research::RoutingModel::VehicleTypeContainer *) &((operations_research::RoutingModel const *)arg1)->GetVehicleTypeContainer();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_ArcIsMoreConstrainedThanArc___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (bool)(arg1)->ArcIsMoreConstrainedThanArc(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_DebugOutputAssignment___(void * jarg1, void * jarg2, char * jarg3) {
  char * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Assignment *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::Assignment *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::Assignment const & type is null", 0);
    return 0;
  } 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  result = ((operations_research::RoutingModel const *)arg1)->DebugOutputAssignment((operations_research::Assignment const &)*arg2,(std::string const &)*arg3);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_solver___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::Solver *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (operations_research::Solver *)((operations_research::RoutingModel const *)arg1)->solver();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_CheckLimit___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (bool)(arg1)->CheckLimit();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_Nodes___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->nodes();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_Vehicles___(void * jarg1) {
  int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int)((operations_research::RoutingModel const *)arg1)->vehicles();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_Size___(void * jarg1) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->Size();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetNumberOfDecisionsInFirstSolution___(void * jarg1, int search_parameters_size, uint8_t* jarg2) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingSearchParameters *arg2 = 0 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg2->ParseFromArray(jarg2, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetNumberOfDecisionsInFirstSolution((operations_research::RoutingSearchParameters const &)*arg2);
  jresult = result; 
  {
    delete arg2;
  }
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_GetNumberOfRejectsInFirstSolution___(void * jarg1, int search_parameters_size, uint8_t* jarg2) {
  long long jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingSearchParameters *arg2 = 0 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  {
    arg2 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg2->ParseFromArray(jarg2, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  result = (int64_t)((operations_research::RoutingModel const *)arg1)->GetNumberOfRejectsInFirstSolution((operations_research::RoutingSearchParameters const &)*arg2);
  jresult = result; 
  {
    delete arg2;
  }
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_IsMatchingModel___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  result = (bool)((operations_research::RoutingModel const *)arg1)->IsMatchingModel();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_MakeGuidedSlackFinalizer___(void * jarg1, void * jarg2,  void *  jarg3) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingDimension *arg2 = (operations_research::RoutingDimension *) 0 ;
  std::function< int64_t (int64_t) > arg3 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::RoutingDimension *)jarg2; 
  
  arg3 = [jarg3](int64_t t) -> int64_t {
    return (*(int64_t(*)(int64_t))jarg3)(t);
  };
  
  result = (operations_research::DecisionBuilder *)(arg1)->MakeGuidedSlackFinalizer((operations_research::RoutingDimension const *)arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModel_MakeSelfDependentDimensionFinalizer___(void * jarg1, void * jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = (operations_research::RoutingModel *) 0 ;
  operations_research::RoutingDimension *arg2 = (operations_research::RoutingDimension *) 0 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1; 
  arg2 = (operations_research::RoutingDimension *)jarg2; 
  result = (operations_research::DecisionBuilder *)(arg1)->MakeSelfDependentDimensionFinalizer((operations_research::RoutingDimension const *)arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModelVisitor_kLightElement_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::RoutingModelVisitor::kLightElement;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModelVisitor_kLightElement2_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::RoutingModelVisitor::kLightElement2;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModelVisitor_kRemoveValues_get___() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)(char *)operations_research::RoutingModelVisitor::kRemoveValues;
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_RoutingModelVisitor___() {
  void * jresult ;
  operations_research::RoutingModelVisitor *result = 0 ;
  
  result = (operations_research::RoutingModelVisitor *)new operations_research::RoutingModelVisitor();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RoutingModelVisitor___(void * jarg1) {
  operations_research::RoutingModelVisitor *arg1 = (operations_research::RoutingModelVisitor *) 0 ;
  
  arg1 = (operations_research::RoutingModelVisitor *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_GlobalVehicleBreaksConstraint___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  operations_research::GlobalVehicleBreaksConstraint *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (operations_research::GlobalVehicleBreaksConstraint *)new operations_research::GlobalVehicleBreaksConstraint((operations_research::RoutingDimension const *)arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_GlobalVehicleBreaksConstraint_ToString___(void * jarg1) {
  char * jresult ;
  operations_research::GlobalVehicleBreaksConstraint *arg1 = (operations_research::GlobalVehicleBreaksConstraint *) 0 ;
  std::string result;
  
  arg1 = (operations_research::GlobalVehicleBreaksConstraint *)jarg1; 
  result = ((operations_research::GlobalVehicleBreaksConstraint const *)arg1)->DebugString();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_GlobalVehicleBreaksConstraint_Post___(void * jarg1) {
  operations_research::GlobalVehicleBreaksConstraint *arg1 = (operations_research::GlobalVehicleBreaksConstraint *) 0 ;
  
  arg1 = (operations_research::GlobalVehicleBreaksConstraint *)jarg1; 
  (arg1)->Post();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_GlobalVehicleBreaksConstraint_InitialPropagateWrapper___(void * jarg1) {
  operations_research::GlobalVehicleBreaksConstraint *arg1 = (operations_research::GlobalVehicleBreaksConstraint *) 0 ;
  
  arg1 = (operations_research::GlobalVehicleBreaksConstraint *)jarg1; 
  (arg1)->InitialPropagate();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_GlobalVehicleBreaksConstraint___(void * jarg1) {
  operations_research::GlobalVehicleBreaksConstraint *arg1 = (operations_research::GlobalVehicleBreaksConstraint *) 0 ;
  
  arg1 = (operations_research::GlobalVehicleBreaksConstraint *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_TypeRegulationsChecker___(void * jarg1) {
  operations_research::TypeRegulationsChecker *arg1 = (operations_research::TypeRegulationsChecker *) 0 ;
  
  arg1 = (operations_research::TypeRegulationsChecker *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_TypeIncompatibilityChecker___(void * jarg1, unsigned int jarg2) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = 0 ;
  bool arg2 ;
  operations_research::TypeIncompatibilityChecker *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::RoutingModel const & type is null", 0);
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  result = (operations_research::TypeIncompatibilityChecker *)new operations_research::TypeIncompatibilityChecker((operations_research::RoutingModel const &)*arg1,arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_TypeIncompatibilityChecker___(void * jarg1) {
  operations_research::TypeIncompatibilityChecker *arg1 = (operations_research::TypeIncompatibilityChecker *) 0 ;
  
  arg1 = (operations_research::TypeIncompatibilityChecker *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_TypeRequirementChecker___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = 0 ;
  operations_research::TypeRequirementChecker *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::RoutingModel const & type is null", 0);
    return 0;
  } 
  result = (operations_research::TypeRequirementChecker *)new operations_research::TypeRequirementChecker((operations_research::RoutingModel const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_TypeRequirementChecker___(void * jarg1) {
  operations_research::TypeRequirementChecker *arg1 = (operations_research::TypeRequirementChecker *) 0 ;
  
  arg1 = (operations_research::TypeRequirementChecker *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_new_TypeRegulationsConstraint___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingModel *arg1 = 0 ;
  operations_research::TypeRegulationsConstraint *result = 0 ;
  
  arg1 = (operations_research::RoutingModel *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::RoutingModel const & type is null", 0);
    return 0;
  } 
  result = (operations_research::TypeRegulationsConstraint *)new operations_research::TypeRegulationsConstraint((operations_research::RoutingModel const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_TypeRegulationsConstraint_Post___(void * jarg1) {
  operations_research::TypeRegulationsConstraint *arg1 = (operations_research::TypeRegulationsConstraint *) 0 ;
  
  arg1 = (operations_research::TypeRegulationsConstraint *)jarg1; 
  (arg1)->Post();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_TypeRegulationsConstraint_InitialPropagateWrapper___(void * jarg1) {
  operations_research::TypeRegulationsConstraint *arg1 = (operations_research::TypeRegulationsConstraint *) 0 ;
  
  arg1 = (operations_research::TypeRegulationsConstraint *)jarg1; 
  (arg1)->InitialPropagate();
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_TypeRegulationsConstraint___(void * jarg1) {
  operations_research::TypeRegulationsConstraint *arg1 = (operations_research::TypeRegulationsConstraint *) 0 ;
  
  arg1 = (operations_research::TypeRegulationsConstraint *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_delete_RoutingDimension___(void * jarg1) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  delete arg1;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_Model___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  operations_research::RoutingModel *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (operations_research::RoutingModel *)((operations_research::RoutingDimension const *)arg1)->model();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetTransitValue___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetTransitValue(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetTransitValueFromClass___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetTransitValueFromClass(arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_CumulVar___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingDimension const *)arg1)->CumulVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_TransitVar___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingDimension const *)arg1)->TransitVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_FixedTransitVar___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingDimension const *)arg1)->FixedTransitVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SlackVar___(void * jarg1, long long jarg2) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  operations_research::IntVar *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (operations_research::IntVar *)((operations_research::RoutingDimension const *)arg1)->SlackVar(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_Cumuls___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (std::vector< operations_research::IntVar * > *) &((operations_research::RoutingDimension const *)arg1)->cumuls();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_FixedTransits___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (std::vector< operations_research::IntVar * > *) &((operations_research::RoutingDimension const *)arg1)->fixed_transits();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_Transits___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (std::vector< operations_research::IntVar * > *) &((operations_research::RoutingDimension const *)arg1)->transits();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_Slacks___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  std::vector< operations_research::IntVar * > *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (std::vector< operations_research::IntVar * > *) &((operations_research::RoutingDimension const *)arg1)->slacks();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetSpanUpperBoundForVehicle___(void * jarg1, long long jarg2, int jarg3) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->SetSpanUpperBoundForVehicle(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetSpanCostCoefficientForVehicle___(void * jarg1, long long jarg2, int jarg3) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int)jarg3; 
  (arg1)->SetSpanCostCoefficientForVehicle(arg2,arg3);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetSpanCostCoefficientForAllVehicles___(void * jarg1, long long jarg2) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetSpanCostCoefficientForAllVehicles(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetGlobalSpanCostCoefficient___(void * jarg1, long long jarg2) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  (arg1)->SetGlobalSpanCostCoefficient(arg2);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetCumulVarSoftUpperBound___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetCumulVarSoftUpperBound(arg2,arg3,arg4);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_HasCumulVarSoftUpperBound___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (bool)((operations_research::RoutingDimension const *)arg1)->HasCumulVarSoftUpperBound(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetCumulVarSoftUpperBound___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetCumulVarSoftUpperBound(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetCumulVarSoftUpperBoundCoefficient___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetCumulVarSoftUpperBoundCoefficient(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetCumulVarSoftLowerBound___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->SetCumulVarSoftLowerBound(arg2,arg3,arg4);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_HasCumulVarSoftLowerBound___(void * jarg1, long long jarg2) {
  unsigned int jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  bool result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (bool)((operations_research::RoutingDimension const *)arg1)->HasCumulVarSoftLowerBound(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetCumulVarSoftLowerBound___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetCumulVarSoftLowerBound(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetCumulVarSoftLowerBoundCoefficient___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetCumulVarSoftLowerBoundCoefficient(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetBreakIntervalsOfVehicle__SWIG_0___(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  std::vector< operations_research::IntervalVar * > arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::vector< operations_research::IntervalVar * > *argp2 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  argp2 = (std::vector< operations_research::IntervalVar * > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::IntervalVar * >", 0);
    return ;
  }
  arg2 = *argp2; 
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  arg5 = (int)jarg5; 
  (arg1)->SetBreakIntervalsOfVehicle(arg2,arg3,arg4,arg5);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetBreakIntervalsOfVehicle__SWIG_1___(void * jarg1, void * jarg2, int jarg3,  int length4, int64_t*  jarg4) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  std::vector< operations_research::IntervalVar * > arg2 ;
  int arg3 ;
  std::vector< int64_t > arg4 ;
  std::vector< operations_research::IntervalVar * > *argp2 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  argp2 = (std::vector< operations_research::IntervalVar * > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::IntervalVar * >", 0);
    return ;
  }
  arg2 = *argp2; 
  arg3 = (int)jarg3; 
  
  (&arg4)->clear();
  (&arg4)->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    (&arg4)->emplace_back(jarg4[i]);
  }
  
  (arg1)->SetBreakIntervalsOfVehicle(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetBreakDistanceDurationOfVehicle___(void * jarg1, long long jarg2, long long jarg3, int jarg4) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int arg4 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int)jarg4; 
  (arg1)->SetBreakDistanceDurationOfVehicle(arg2,arg3,arg4);
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_InitializeBreaks___(void * jarg1) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  (arg1)->InitializeBreaks();
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_HasBreakConstraints___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (bool)((operations_research::RoutingDimension const *)arg1)->HasBreakConstraints();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetBreakIntervalsOfVehicle__SWIG_2___(void * jarg1, void * jarg2, int jarg3,  int length4, int64_t*  jarg4,  void *  jarg5) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  std::vector< operations_research::IntervalVar * > arg2 ;
  int arg3 ;
  std::vector< int64_t > arg4 ;
  std::function< int64_t (int64_t,int64_t) > arg5 ;
  std::vector< operations_research::IntervalVar * > *argp2 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  argp2 = (std::vector< operations_research::IntervalVar * > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::IntervalVar * >", 0);
    return ;
  }
  arg2 = *argp2; 
  arg3 = (int)jarg3; 
  
  (&arg4)->clear();
  (&arg4)->reserve(length4);
  for(int i = 0; i < length4; ++i) {
    (&arg4)->emplace_back(jarg4[i]);
  }
  
  
  arg5 = [jarg5](int64_t t, int64_t u) -> int64_t {
    return (*(int64_t(*)(int64_t, int64_t))jarg5)(t, u);
  };
  
  (arg1)->SetBreakIntervalsOfVehicle(arg2,arg3,arg4,arg5);
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetBreakIntervalsOfVehicle___(void * jarg1, int jarg2) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int arg2 ;
  std::vector< operations_research::IntervalVar * > *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int)jarg2; 
  result = (std::vector< operations_research::IntervalVar * > *) &((operations_research::RoutingDimension const *)arg1)->GetBreakIntervalsOfVehicle(arg2);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetPreTravelEvaluatorOfVehicle___(void * jarg1, int jarg2) {
  int jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int)((operations_research::RoutingDimension const *)arg1)->GetPreTravelEvaluatorOfVehicle(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetPostTravelEvaluatorOfVehicle___(void * jarg1, int jarg2) {
  int jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int)((operations_research::RoutingDimension const *)arg1)->GetPostTravelEvaluatorOfVehicle(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_BaseDimension___(void * jarg1) {
  void * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  operations_research::RoutingDimension *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (operations_research::RoutingDimension *)((operations_research::RoutingDimension const *)arg1)->base_dimension();
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_ShortestTransitionSlack___(void * jarg1, long long jarg2) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->ShortestTransitionSlack(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT char * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_Name___(void * jarg1) {
  char * jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  std::string *result = 0 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (std::string *) &((operations_research::RoutingDimension const *)arg1)->name();
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_SetPickupToDeliveryLimitFunctionForPair___(void * jarg1,  void *  jarg2, int jarg3) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  operations_research::RoutingDimension::PickupToDeliveryLimitFunction arg2 ;
  int arg3 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  
  arg2 = [jarg2](int t, int u) -> int64_t {
    return (*(int64_t(*)(int, int))jarg2)(t, u);
  };
  
  arg3 = (int)jarg3; 
  (arg1)->SetPickupToDeliveryLimitFunctionForPair(arg2,arg3);
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_HasPickupToDeliveryLimits___(void * jarg1) {
  unsigned int jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (bool)((operations_research::RoutingDimension const *)arg1)->HasPickupToDeliveryLimits();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_AddNodePrecedence___(void * jarg1, long long jarg2, long long jarg3, long long jarg4) {
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t arg2 ;
  int64_t arg3 ;
  int64_t arg4 ;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int64_t)jarg2; 
  arg3 = (int64_t)jarg3; 
  arg4 = (int64_t)jarg4; 
  (arg1)->AddNodePrecedence(arg2,arg3,arg4);
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetSpanUpperBoundForVehicle___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetSpanUpperBoundForVehicle(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetSpanCostCoefficientForVehicle___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetSpanCostCoefficientForVehicle(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GlobalSpanCostCoefficient___(void * jarg1) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->global_span_cost_coefficient();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetGlobalOptimizerOffset___(void * jarg1) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetGlobalOptimizerOffset();
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT long long SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingDimension_GetLocalOptimizerOffsetForVehicle___(void * jarg1, int jarg2) {
  long long jresult ;
  operations_research::RoutingDimension *arg1 = (operations_research::RoutingDimension *) 0 ;
  int arg2 ;
  int64_t result;
  
  arg1 = (operations_research::RoutingDimension *)jarg1; 
  arg2 = (int)jarg2; 
  result = (int64_t)((operations_research::RoutingDimension const *)arg1)->GetLocalOptimizerOffsetForVehicle(arg2);
  jresult = result; 
  return jresult;
}
 
 
SWIGEXPORT void * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_MakeSetValuesFromTargets___(void * jarg1, void * jarg2,  int length3, int64_t*  jarg3) {
  void * jresult ;
  operations_research::Solver *arg1 = (operations_research::Solver *) 0 ;
  std::vector< operations_research::IntVar * > arg2 ;
  std::vector< int64_t > arg3 ;
  std::vector< operations_research::IntVar * > *argp2 ;
  operations_research::DecisionBuilder *result = 0 ;
  
  arg1 = (operations_research::Solver *)jarg1; 
  argp2 = (std::vector< operations_research::IntVar * > *)jarg2; 
  if (!argp2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null std::vector< operations_research::IntVar * >", 0);
    return 0;
  }
  arg2 = *argp2; 
  
  (&arg3)->clear();
  (&arg3)->reserve(length3);
  for(int i = 0; i < length3; ++i) {
    (&arg3)->emplace_back(jarg3[i]);
  }
  
  result = (operations_research::DecisionBuilder *)operations_research::MakeSetValuesFromTargets(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}
 
 
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolveModelWithSat___(void * jarg1, int search_parameters_size, uint8_t* jarg2, void * jarg3, void * jarg4) {
  unsigned int jresult ;
  operations_research::RoutingModel *arg1 = 0 ;
  operations_research::RoutingSearchParameters *arg2 = 0 ;
  operations_research::Assignment *arg3 = (operations_research::Assignment *) 0 ;
  operations_research::Assignment *arg4 = (operations_research::Assignment *) 0 ;
  bool result;
  
  arg1 = (operations_research::RoutingModel *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "operations_research::RoutingModel const & type is null", 0);
    return 0;
  } 
  {
    arg2 = new operations_research::RoutingSearchParameters;
    bool parsed_ok = arg2->ParseFromArray(jarg2, search_parameters_size);
    if (!parsed_ok) {
      SWIG_CSharpSetPendingException(
        SWIG_CSharpSystemException,
        "Unable to parse operations_research::RoutingSearchParameters protocol message.");
    }
  }
  arg3 = (operations_research::Assignment *)jarg3; 
  arg4 = (operations_research::Assignment *)jarg4; 
  result = (bool)operations_research::SolveModelWithSat((operations_research::RoutingModel const &)*arg1,(operations_research::RoutingSearchParameters const &)*arg2,(operations_research::Assignment const *)arg3,arg4);
  jresult = result; 
  {
    delete arg2;
  }
  return jresult;
}
 
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationBaseObject_SWIGUpcast___(operations_research::PropagationBaseObject *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Decision_SWIGUpcast___(operations_research::Decision *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionVisitor_SWIGUpcast___(operations_research::DecisionVisitor *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DecisionBuilder_SWIGUpcast___(operations_research::DecisionBuilder *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Demon_SWIGUpcast___(operations_research::Demon *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ModelVisitor_SWIGUpcast___(operations_research::ModelVisitor *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::PropagationBaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Constraint_SWIGUpcast___(operations_research::Constraint *jarg1) {
    return (operations_research::PropagationBaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::Constraint * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_CastConstraint_SWIGUpcast___(operations_research::CastConstraint *jarg1) {
    return (operations_research::Constraint *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchMonitor_SWIGUpcast___(operations_research::SearchMonitor *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::PropagationBaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntExpr_SWIGUpcast___(operations_research::IntExpr *jarg1) {
    return (operations_research::PropagationBaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarIterator_SWIGUpcast___(operations_research::IntVarIterator *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::IntExpr * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVar_SWIGUpcast___(operations_research::IntVar *jarg1) {
    return (operations_research::IntExpr *)jarg1;
}
 
SWIGEXPORT operations_research::SearchMonitor * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionCollector_SWIGUpcast___(operations_research::SolutionCollector *jarg1) {
    return (operations_research::SearchMonitor *)jarg1;
}
 
SWIGEXPORT operations_research::SearchMonitor * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_OptimizeVar_SWIGUpcast___(operations_research::OptimizeVar *jarg1) {
    return (operations_research::SearchMonitor *)jarg1;
}
 
SWIGEXPORT operations_research::SearchMonitor * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLimit_SWIGUpcast___(operations_research::SearchLimit *jarg1) {
    return (operations_research::SearchMonitor *)jarg1;
}
 
SWIGEXPORT operations_research::SearchLimit * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RegularLimit_SWIGUpcast___(operations_research::RegularLimit *jarg1) {
    return (operations_research::SearchLimit *)jarg1;
}
 
SWIGEXPORT operations_research::SearchLimit * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ImprovementSearchLimit_SWIGUpcast___(operations_research::ImprovementSearchLimit *jarg1) {
    return (operations_research::SearchLimit *)jarg1;
}
 
SWIGEXPORT operations_research::PropagationBaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVar_SWIGUpcast___(operations_research::IntervalVar *jarg1) {
    return (operations_research::PropagationBaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::PropagationBaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVar_SWIGUpcast___(operations_research::SequenceVar *jarg1) {
    return (operations_research::PropagationBaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::AssignmentElement * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarElement_SWIGUpcast___(operations_research::IntVarElement *jarg1) {
    return (operations_research::AssignmentElement *)jarg1;
}
 
SWIGEXPORT operations_research::AssignmentElement * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntervalVarElement_SWIGUpcast___(operations_research::IntervalVarElement *jarg1) {
    return (operations_research::AssignmentElement *)jarg1;
}
 
SWIGEXPORT operations_research::AssignmentElement * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarElement_SWIGUpcast___(operations_research::SequenceVarElement *jarg1) {
    return (operations_research::AssignmentElement *)jarg1;
}
 
SWIGEXPORT operations_research::PropagationBaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Assignment_SWIGUpcast___(operations_research::Assignment *jarg1) {
    return (operations_research::PropagationBaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::Constraint * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_Pack_SWIGUpcast___(operations_research::Pack *jarg1) {
    return (operations_research::Constraint *)jarg1;
}
 
SWIGEXPORT operations_research::Constraint * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_DisjunctiveConstraint_SWIGUpcast___(operations_research::DisjunctiveConstraint *jarg1) {
    return (operations_research::Constraint *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SolutionPool_SWIGUpcast___(operations_research::SolutionPool *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::IntExpr * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseIntExpr_SWIGUpcast___(operations_research::BaseIntExpr *jarg1) {
    return (operations_research::IntExpr *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchOperator_SWIGUpcast___(operations_research::LocalSearchOperator *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::LocalSearchOperator * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperatorTemplate_SWIGUpcast___(operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *jarg1) {
    return (operations_research::LocalSearchOperator *)jarg1;
}
 
SWIGEXPORT operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchOperator_SWIGUpcast___(operations_research::IntVarLocalSearchOperator *jarg1) {
    return (operations_research::VarLocalSearchOperator< operations_research::IntVar,int64_t,operations_research::IntVarLocalSearchHandler > *)jarg1;
}
 
SWIGEXPORT operations_research::LocalSearchOperator * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperatorTemplate_SWIGUpcast___(operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *jarg1) {
    return (operations_research::LocalSearchOperator *)jarg1;
}
 
SWIGEXPORT operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SequenceVarLocalSearchOperator_SWIGUpcast___(operations_research::SequenceVarLocalSearchOperator *jarg1) {
    return (operations_research::VarLocalSearchOperator< operations_research::SequenceVar,std::vector< int >,operations_research::SequenceVarLocalSearchHandler > *)jarg1;
}
 
SWIGEXPORT operations_research::IntVarLocalSearchOperator * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BaseLns_SWIGUpcast___(operations_research::BaseLns *jarg1) {
    return (operations_research::IntVarLocalSearchOperator *)jarg1;
}
 
SWIGEXPORT operations_research::IntVarLocalSearchOperator * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_ChangeValue_SWIGUpcast___(operations_research::ChangeValue *jarg1) {
    return (operations_research::IntVarLocalSearchOperator *)jarg1;
}
 
SWIGEXPORT operations_research::IntVarLocalSearchOperator * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PathOperator_SWIGUpcast___(operations_research::PathOperator *jarg1) {
    return (operations_research::IntVarLocalSearchOperator *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilter_SWIGUpcast___(operations_research::LocalSearchFilter *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchFilterManager_SWIGUpcast___(operations_research::LocalSearchFilterManager *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::LocalSearchFilter * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_IntVarLocalSearchFilter_SWIGUpcast___(operations_research::IntVarLocalSearchFilter *jarg1) {
    return (operations_research::LocalSearchFilter *)jarg1;
}
 
SWIGEXPORT operations_research::SearchMonitor * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_PropagationMonitor_SWIGUpcast___(operations_research::PropagationMonitor *jarg1) {
    return (operations_research::SearchMonitor *)jarg1;
}
 
SWIGEXPORT operations_research::SearchMonitor * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_LocalSearchMonitor_SWIGUpcast___(operations_research::LocalSearchMonitor *jarg1) {
    return (operations_research::SearchMonitor *)jarg1;
}
 
SWIGEXPORT operations_research::IntVar * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_BooleanVar_SWIGUpcast___(operations_research::BooleanVar *jarg1) {
    return (operations_research::IntVar *)jarg1;
}
 
SWIGEXPORT operations_research::DecisionVisitor * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SymmetryBreaker_SWIGUpcast___(operations_research::SymmetryBreaker *jarg1) {
    return (operations_research::DecisionVisitor *)jarg1;
}
 
SWIGEXPORT operations_research::SearchMonitor * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_SearchLog_SWIGUpcast___(operations_research::SearchLog *jarg1) {
    return (operations_research::SearchMonitor *)jarg1;
}
 
SWIGEXPORT operations_research::BaseObject * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_RoutingModelVisitor_SWIGUpcast___(operations_research::RoutingModelVisitor *jarg1) {
    return (operations_research::BaseObject *)jarg1;
}
 
SWIGEXPORT operations_research::Constraint * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_GlobalVehicleBreaksConstraint_SWIGUpcast___(operations_research::GlobalVehicleBreaksConstraint *jarg1) {
    return (operations_research::Constraint *)jarg1;
}
 
SWIGEXPORT operations_research::TypeRegulationsChecker * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_TypeIncompatibilityChecker_SWIGUpcast___(operations_research::TypeIncompatibilityChecker *jarg1) {
    return (operations_research::TypeRegulationsChecker *)jarg1;
}
 
SWIGEXPORT operations_research::TypeRegulationsChecker * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_TypeRequirementChecker_SWIGUpcast___(operations_research::TypeRequirementChecker *jarg1) {
    return (operations_research::TypeRegulationsChecker *)jarg1;
}
 
SWIGEXPORT operations_research::Constraint * SWIGSTDCALL CSharp_GooglefOrToolsfConstraintSolver_TypeRegulationsConstraint_SWIGUpcast___(operations_research::TypeRegulationsConstraint *jarg1) {
    return (operations_research::Constraint *)jarg1;
}
 
#ifdef __cplusplus
}
#endif