cp_model.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ortools/sat/cp_model.proto

#ifndef PROTOBUF_INCLUDED_ortools_2fsat_2fcp_5fmodel_2eproto
#define PROTOBUF_INCLUDED_ortools_2fsat_2fcp_5fmodel_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3007000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3007001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_ortools_2fsat_2fcp_5fmodel_2eproto

// Internal implementation detail -- do not use these members.
struct TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto {
  static const ::google::protobuf::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::ParseTable schema[24]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors_ortools_2fsat_2fcp_5fmodel_2eproto();
namespace operations_research {
namespace sat {
class AllDifferentConstraintProto;
class AllDifferentConstraintProtoDefaultTypeInternal;
extern AllDifferentConstraintProtoDefaultTypeInternal _AllDifferentConstraintProto_default_instance_;
class AutomatonConstraintProto;
class AutomatonConstraintProtoDefaultTypeInternal;
extern AutomatonConstraintProtoDefaultTypeInternal _AutomatonConstraintProto_default_instance_;
class BoolArgumentProto;
class BoolArgumentProtoDefaultTypeInternal;
extern BoolArgumentProtoDefaultTypeInternal _BoolArgumentProto_default_instance_;
class CircuitConstraintProto;
class CircuitConstraintProtoDefaultTypeInternal;
extern CircuitConstraintProtoDefaultTypeInternal _CircuitConstraintProto_default_instance_;
class CircuitCoveringConstraintProto;
class CircuitCoveringConstraintProtoDefaultTypeInternal;
extern CircuitCoveringConstraintProtoDefaultTypeInternal _CircuitCoveringConstraintProto_default_instance_;
class ConstraintProto;
class ConstraintProtoDefaultTypeInternal;
extern ConstraintProtoDefaultTypeInternal _ConstraintProto_default_instance_;
class CpModelProto;
class CpModelProtoDefaultTypeInternal;
extern CpModelProtoDefaultTypeInternal _CpModelProto_default_instance_;
class CpObjectiveProto;
class CpObjectiveProtoDefaultTypeInternal;
extern CpObjectiveProtoDefaultTypeInternal _CpObjectiveProto_default_instance_;
class CpSolverResponse;
class CpSolverResponseDefaultTypeInternal;
extern CpSolverResponseDefaultTypeInternal _CpSolverResponse_default_instance_;
class CumulativeConstraintProto;
class CumulativeConstraintProtoDefaultTypeInternal;
extern CumulativeConstraintProtoDefaultTypeInternal _CumulativeConstraintProto_default_instance_;
class DecisionStrategyProto;
class DecisionStrategyProtoDefaultTypeInternal;
extern DecisionStrategyProtoDefaultTypeInternal _DecisionStrategyProto_default_instance_;
class DecisionStrategyProto_AffineTransformation;
class DecisionStrategyProto_AffineTransformationDefaultTypeInternal;
extern DecisionStrategyProto_AffineTransformationDefaultTypeInternal _DecisionStrategyProto_AffineTransformation_default_instance_;
class ElementConstraintProto;
class ElementConstraintProtoDefaultTypeInternal;
extern ElementConstraintProtoDefaultTypeInternal _ElementConstraintProto_default_instance_;
class IntegerArgumentProto;
class IntegerArgumentProtoDefaultTypeInternal;
extern IntegerArgumentProtoDefaultTypeInternal _IntegerArgumentProto_default_instance_;
class IntegerVariableProto;
class IntegerVariableProtoDefaultTypeInternal;
extern IntegerVariableProtoDefaultTypeInternal _IntegerVariableProto_default_instance_;
class IntervalConstraintProto;
class IntervalConstraintProtoDefaultTypeInternal;
extern IntervalConstraintProtoDefaultTypeInternal _IntervalConstraintProto_default_instance_;
class InverseConstraintProto;
class InverseConstraintProtoDefaultTypeInternal;
extern InverseConstraintProtoDefaultTypeInternal _InverseConstraintProto_default_instance_;
class LinearConstraintProto;
class LinearConstraintProtoDefaultTypeInternal;
extern LinearConstraintProtoDefaultTypeInternal _LinearConstraintProto_default_instance_;
class NoOverlap2DConstraintProto;
class NoOverlap2DConstraintProtoDefaultTypeInternal;
extern NoOverlap2DConstraintProtoDefaultTypeInternal _NoOverlap2DConstraintProto_default_instance_;
class NoOverlapConstraintProto;
class NoOverlapConstraintProtoDefaultTypeInternal;
extern NoOverlapConstraintProtoDefaultTypeInternal _NoOverlapConstraintProto_default_instance_;
class PartialVariableAssignment;
class PartialVariableAssignmentDefaultTypeInternal;
extern PartialVariableAssignmentDefaultTypeInternal _PartialVariableAssignment_default_instance_;
class ReservoirConstraintProto;
class ReservoirConstraintProtoDefaultTypeInternal;
extern ReservoirConstraintProtoDefaultTypeInternal _ReservoirConstraintProto_default_instance_;
class RoutesConstraintProto;
class RoutesConstraintProtoDefaultTypeInternal;
extern RoutesConstraintProtoDefaultTypeInternal _RoutesConstraintProto_default_instance_;
class TableConstraintProto;
class TableConstraintProtoDefaultTypeInternal;
extern TableConstraintProtoDefaultTypeInternal _TableConstraintProto_default_instance_;
}  // namespace sat
}  // namespace operations_research
namespace google {
namespace protobuf {
template<> ::operations_research::sat::AllDifferentConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::AllDifferentConstraintProto>(Arena*);
template<> ::operations_research::sat::AutomatonConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::AutomatonConstraintProto>(Arena*);
template<> ::operations_research::sat::BoolArgumentProto* Arena::CreateMaybeMessage<::operations_research::sat::BoolArgumentProto>(Arena*);
template<> ::operations_research::sat::CircuitConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::CircuitConstraintProto>(Arena*);
template<> ::operations_research::sat::CircuitCoveringConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::CircuitCoveringConstraintProto>(Arena*);
template<> ::operations_research::sat::ConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::ConstraintProto>(Arena*);
template<> ::operations_research::sat::CpModelProto* Arena::CreateMaybeMessage<::operations_research::sat::CpModelProto>(Arena*);
template<> ::operations_research::sat::CpObjectiveProto* Arena::CreateMaybeMessage<::operations_research::sat::CpObjectiveProto>(Arena*);
template<> ::operations_research::sat::CpSolverResponse* Arena::CreateMaybeMessage<::operations_research::sat::CpSolverResponse>(Arena*);
template<> ::operations_research::sat::CumulativeConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::CumulativeConstraintProto>(Arena*);
template<> ::operations_research::sat::DecisionStrategyProto* Arena::CreateMaybeMessage<::operations_research::sat::DecisionStrategyProto>(Arena*);
template<> ::operations_research::sat::DecisionStrategyProto_AffineTransformation* Arena::CreateMaybeMessage<::operations_research::sat::DecisionStrategyProto_AffineTransformation>(Arena*);
template<> ::operations_research::sat::ElementConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::ElementConstraintProto>(Arena*);
template<> ::operations_research::sat::IntegerArgumentProto* Arena::CreateMaybeMessage<::operations_research::sat::IntegerArgumentProto>(Arena*);
template<> ::operations_research::sat::IntegerVariableProto* Arena::CreateMaybeMessage<::operations_research::sat::IntegerVariableProto>(Arena*);
template<> ::operations_research::sat::IntervalConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::IntervalConstraintProto>(Arena*);
template<> ::operations_research::sat::InverseConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::InverseConstraintProto>(Arena*);
template<> ::operations_research::sat::LinearConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::LinearConstraintProto>(Arena*);
template<> ::operations_research::sat::NoOverlap2DConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::NoOverlap2DConstraintProto>(Arena*);
template<> ::operations_research::sat::NoOverlapConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::NoOverlapConstraintProto>(Arena*);
template<> ::operations_research::sat::PartialVariableAssignment* Arena::CreateMaybeMessage<::operations_research::sat::PartialVariableAssignment>(Arena*);
template<> ::operations_research::sat::ReservoirConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::ReservoirConstraintProto>(Arena*);
template<> ::operations_research::sat::RoutesConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::RoutesConstraintProto>(Arena*);
template<> ::operations_research::sat::TableConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::TableConstraintProto>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace operations_research {
namespace sat {

enum DecisionStrategyProto_VariableSelectionStrategy {
  DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_FIRST = 0,
  DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_LOWEST_MIN = 1,
  DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_HIGHEST_MAX = 2,
  DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_MIN_DOMAIN_SIZE = 3,
  DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_MAX_DOMAIN_SIZE = 4,
  DecisionStrategyProto_VariableSelectionStrategy_DecisionStrategyProto_VariableSelectionStrategy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
  DecisionStrategyProto_VariableSelectionStrategy_DecisionStrategyProto_VariableSelectionStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
};
bool DecisionStrategyProto_VariableSelectionStrategy_IsValid(int value);
const DecisionStrategyProto_VariableSelectionStrategy DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MIN = DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_FIRST;
const DecisionStrategyProto_VariableSelectionStrategy DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MAX = DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_MAX_DOMAIN_SIZE;
const int DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_ARRAYSIZE = DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MAX + 1;

const ::google::protobuf::EnumDescriptor* DecisionStrategyProto_VariableSelectionStrategy_descriptor();
inline const ::std::string& DecisionStrategyProto_VariableSelectionStrategy_Name(DecisionStrategyProto_VariableSelectionStrategy value) {
  return ::google::protobuf::internal::NameOfEnum(
    DecisionStrategyProto_VariableSelectionStrategy_descriptor(), value);
}
inline bool DecisionStrategyProto_VariableSelectionStrategy_Parse(
    const ::std::string& name, DecisionStrategyProto_VariableSelectionStrategy* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DecisionStrategyProto_VariableSelectionStrategy>(
    DecisionStrategyProto_VariableSelectionStrategy_descriptor(), name, value);
}
enum DecisionStrategyProto_DomainReductionStrategy {
  DecisionStrategyProto_DomainReductionStrategy_SELECT_MIN_VALUE = 0,
  DecisionStrategyProto_DomainReductionStrategy_SELECT_MAX_VALUE = 1,
  DecisionStrategyProto_DomainReductionStrategy_SELECT_LOWER_HALF = 2,
  DecisionStrategyProto_DomainReductionStrategy_SELECT_UPPER_HALF = 3,
  DecisionStrategyProto_DomainReductionStrategy_DecisionStrategyProto_DomainReductionStrategy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
  DecisionStrategyProto_DomainReductionStrategy_DecisionStrategyProto_DomainReductionStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
};
bool DecisionStrategyProto_DomainReductionStrategy_IsValid(int value);
const DecisionStrategyProto_DomainReductionStrategy DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MIN = DecisionStrategyProto_DomainReductionStrategy_SELECT_MIN_VALUE;
const DecisionStrategyProto_DomainReductionStrategy DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MAX = DecisionStrategyProto_DomainReductionStrategy_SELECT_UPPER_HALF;
const int DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_ARRAYSIZE = DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MAX + 1;

const ::google::protobuf::EnumDescriptor* DecisionStrategyProto_DomainReductionStrategy_descriptor();
inline const ::std::string& DecisionStrategyProto_DomainReductionStrategy_Name(DecisionStrategyProto_DomainReductionStrategy value) {
  return ::google::protobuf::internal::NameOfEnum(
    DecisionStrategyProto_DomainReductionStrategy_descriptor(), value);
}
inline bool DecisionStrategyProto_DomainReductionStrategy_Parse(
    const ::std::string& name, DecisionStrategyProto_DomainReductionStrategy* value) {
  return ::google::protobuf::internal::ParseNamedEnum<DecisionStrategyProto_DomainReductionStrategy>(
    DecisionStrategyProto_DomainReductionStrategy_descriptor(), name, value);
}
enum CpSolverStatus {
  UNKNOWN = 0,
  MODEL_INVALID = 1,
  FEASIBLE = 2,
  INFEASIBLE = 3,
  OPTIMAL = 4,
  CpSolverStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::min(),
  CpSolverStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::google::protobuf::int32>::max()
};
bool CpSolverStatus_IsValid(int value);
const CpSolverStatus CpSolverStatus_MIN = UNKNOWN;
const CpSolverStatus CpSolverStatus_MAX = OPTIMAL;
const int CpSolverStatus_ARRAYSIZE = CpSolverStatus_MAX + 1;

const ::google::protobuf::EnumDescriptor* CpSolverStatus_descriptor();
inline const ::std::string& CpSolverStatus_Name(CpSolverStatus value) {
  return ::google::protobuf::internal::NameOfEnum(
    CpSolverStatus_descriptor(), value);
}
inline bool CpSolverStatus_Parse(
    const ::std::string& name, CpSolverStatus* value) {
  return ::google::protobuf::internal::ParseNamedEnum<CpSolverStatus>(
    CpSolverStatus_descriptor(), name, value);
}
// ===================================================================

class IntegerVariableProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.IntegerVariableProto) */ {
 public:
  IntegerVariableProto();
  virtual ~IntegerVariableProto();

  IntegerVariableProto(const IntegerVariableProto& from);

  inline IntegerVariableProto& operator=(const IntegerVariableProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  IntegerVariableProto(IntegerVariableProto&& from) noexcept
    : IntegerVariableProto() {
    *this = ::std::move(from);
  }

  inline IntegerVariableProto& operator=(IntegerVariableProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const IntegerVariableProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IntegerVariableProto* internal_default_instance() {
    return reinterpret_cast<const IntegerVariableProto*>(
               &_IntegerVariableProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(IntegerVariableProto* other);
  friend void swap(IntegerVariableProto& a, IntegerVariableProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline IntegerVariableProto* New() const final {
    return CreateMaybeMessage<IntegerVariableProto>(nullptr);
  }

  IntegerVariableProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<IntegerVariableProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const IntegerVariableProto& from);
  void MergeFrom(const IntegerVariableProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IntegerVariableProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int64 domain = 2;
  int domain_size() const;
  void clear_domain();
  static const int kDomainFieldNumber = 2;
  ::google::protobuf::int64 domain(int index) const;
  void set_domain(int index, ::google::protobuf::int64 value);
  void add_domain(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      domain() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_domain();

  // string name = 1;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // @@protoc_insertion_point(class_scope:operations_research.sat.IntegerVariableProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > domain_;
  mutable std::atomic<int> _domain_cached_byte_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class BoolArgumentProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.BoolArgumentProto) */ {
 public:
  BoolArgumentProto();
  virtual ~BoolArgumentProto();

  BoolArgumentProto(const BoolArgumentProto& from);

  inline BoolArgumentProto& operator=(const BoolArgumentProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BoolArgumentProto(BoolArgumentProto&& from) noexcept
    : BoolArgumentProto() {
    *this = ::std::move(from);
  }

  inline BoolArgumentProto& operator=(BoolArgumentProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const BoolArgumentProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BoolArgumentProto* internal_default_instance() {
    return reinterpret_cast<const BoolArgumentProto*>(
               &_BoolArgumentProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(BoolArgumentProto* other);
  friend void swap(BoolArgumentProto& a, BoolArgumentProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline BoolArgumentProto* New() const final {
    return CreateMaybeMessage<BoolArgumentProto>(nullptr);
  }

  BoolArgumentProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BoolArgumentProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const BoolArgumentProto& from);
  void MergeFrom(const BoolArgumentProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoolArgumentProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 literals = 1;
  int literals_size() const;
  void clear_literals();
  static const int kLiteralsFieldNumber = 1;
  ::google::protobuf::int32 literals(int index) const;
  void set_literals(int index, ::google::protobuf::int32 value);
  void add_literals(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      literals() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_literals();

  // @@protoc_insertion_point(class_scope:operations_research.sat.BoolArgumentProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > literals_;
  mutable std::atomic<int> _literals_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class IntegerArgumentProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.IntegerArgumentProto) */ {
 public:
  IntegerArgumentProto();
  virtual ~IntegerArgumentProto();

  IntegerArgumentProto(const IntegerArgumentProto& from);

  inline IntegerArgumentProto& operator=(const IntegerArgumentProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  IntegerArgumentProto(IntegerArgumentProto&& from) noexcept
    : IntegerArgumentProto() {
    *this = ::std::move(from);
  }

  inline IntegerArgumentProto& operator=(IntegerArgumentProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const IntegerArgumentProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IntegerArgumentProto* internal_default_instance() {
    return reinterpret_cast<const IntegerArgumentProto*>(
               &_IntegerArgumentProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(IntegerArgumentProto* other);
  friend void swap(IntegerArgumentProto& a, IntegerArgumentProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline IntegerArgumentProto* New() const final {
    return CreateMaybeMessage<IntegerArgumentProto>(nullptr);
  }

  IntegerArgumentProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<IntegerArgumentProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const IntegerArgumentProto& from);
  void MergeFrom(const IntegerArgumentProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IntegerArgumentProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 vars = 2;
  int vars_size() const;
  void clear_vars();
  static const int kVarsFieldNumber = 2;
  ::google::protobuf::int32 vars(int index) const;
  void set_vars(int index, ::google::protobuf::int32 value);
  void add_vars(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vars() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vars();

  // int32 target = 1;
  void clear_target();
  static const int kTargetFieldNumber = 1;
  ::google::protobuf::int32 target() const;
  void set_target(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.IntegerArgumentProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::google::protobuf::int32 target_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class AllDifferentConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.AllDifferentConstraintProto) */ {
 public:
  AllDifferentConstraintProto();
  virtual ~AllDifferentConstraintProto();

  AllDifferentConstraintProto(const AllDifferentConstraintProto& from);

  inline AllDifferentConstraintProto& operator=(const AllDifferentConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  AllDifferentConstraintProto(AllDifferentConstraintProto&& from) noexcept
    : AllDifferentConstraintProto() {
    *this = ::std::move(from);
  }

  inline AllDifferentConstraintProto& operator=(AllDifferentConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const AllDifferentConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const AllDifferentConstraintProto* internal_default_instance() {
    return reinterpret_cast<const AllDifferentConstraintProto*>(
               &_AllDifferentConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(AllDifferentConstraintProto* other);
  friend void swap(AllDifferentConstraintProto& a, AllDifferentConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline AllDifferentConstraintProto* New() const final {
    return CreateMaybeMessage<AllDifferentConstraintProto>(nullptr);
  }

  AllDifferentConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<AllDifferentConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const AllDifferentConstraintProto& from);
  void MergeFrom(const AllDifferentConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AllDifferentConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 vars = 1;
  int vars_size() const;
  void clear_vars();
  static const int kVarsFieldNumber = 1;
  ::google::protobuf::int32 vars(int index) const;
  void set_vars(int index, ::google::protobuf::int32 value);
  void add_vars(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vars() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vars();

  // @@protoc_insertion_point(class_scope:operations_research.sat.AllDifferentConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class LinearConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.LinearConstraintProto) */ {
 public:
  LinearConstraintProto();
  virtual ~LinearConstraintProto();

  LinearConstraintProto(const LinearConstraintProto& from);

  inline LinearConstraintProto& operator=(const LinearConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LinearConstraintProto(LinearConstraintProto&& from) noexcept
    : LinearConstraintProto() {
    *this = ::std::move(from);
  }

  inline LinearConstraintProto& operator=(LinearConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const LinearConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LinearConstraintProto* internal_default_instance() {
    return reinterpret_cast<const LinearConstraintProto*>(
               &_LinearConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(LinearConstraintProto* other);
  friend void swap(LinearConstraintProto& a, LinearConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline LinearConstraintProto* New() const final {
    return CreateMaybeMessage<LinearConstraintProto>(nullptr);
  }

  LinearConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LinearConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const LinearConstraintProto& from);
  void MergeFrom(const LinearConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinearConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 vars = 1;
  int vars_size() const;
  void clear_vars();
  static const int kVarsFieldNumber = 1;
  ::google::protobuf::int32 vars(int index) const;
  void set_vars(int index, ::google::protobuf::int32 value);
  void add_vars(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vars() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vars();

  // repeated int64 coeffs = 2;
  int coeffs_size() const;
  void clear_coeffs();
  static const int kCoeffsFieldNumber = 2;
  ::google::protobuf::int64 coeffs(int index) const;
  void set_coeffs(int index, ::google::protobuf::int64 value);
  void add_coeffs(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      coeffs() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_coeffs();

  // repeated int64 domain = 3;
  int domain_size() const;
  void clear_domain();
  static const int kDomainFieldNumber = 3;
  ::google::protobuf::int64 domain(int index) const;
  void set_domain(int index, ::google::protobuf::int64 value);
  void add_domain(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      domain() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_domain();

  // @@protoc_insertion_point(class_scope:operations_research.sat.LinearConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > coeffs_;
  mutable std::atomic<int> _coeffs_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > domain_;
  mutable std::atomic<int> _domain_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class ElementConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.ElementConstraintProto) */ {
 public:
  ElementConstraintProto();
  virtual ~ElementConstraintProto();

  ElementConstraintProto(const ElementConstraintProto& from);

  inline ElementConstraintProto& operator=(const ElementConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ElementConstraintProto(ElementConstraintProto&& from) noexcept
    : ElementConstraintProto() {
    *this = ::std::move(from);
  }

  inline ElementConstraintProto& operator=(ElementConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const ElementConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ElementConstraintProto* internal_default_instance() {
    return reinterpret_cast<const ElementConstraintProto*>(
               &_ElementConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(ElementConstraintProto* other);
  friend void swap(ElementConstraintProto& a, ElementConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ElementConstraintProto* New() const final {
    return CreateMaybeMessage<ElementConstraintProto>(nullptr);
  }

  ElementConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ElementConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ElementConstraintProto& from);
  void MergeFrom(const ElementConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ElementConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 vars = 3;
  int vars_size() const;
  void clear_vars();
  static const int kVarsFieldNumber = 3;
  ::google::protobuf::int32 vars(int index) const;
  void set_vars(int index, ::google::protobuf::int32 value);
  void add_vars(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vars() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vars();

  // int32 index = 1;
  void clear_index();
  static const int kIndexFieldNumber = 1;
  ::google::protobuf::int32 index() const;
  void set_index(::google::protobuf::int32 value);

  // int32 target = 2;
  void clear_target();
  static const int kTargetFieldNumber = 2;
  ::google::protobuf::int32 target() const;
  void set_target(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.ElementConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::google::protobuf::int32 index_;
  ::google::protobuf::int32 target_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class IntervalConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.IntervalConstraintProto) */ {
 public:
  IntervalConstraintProto();
  virtual ~IntervalConstraintProto();

  IntervalConstraintProto(const IntervalConstraintProto& from);

  inline IntervalConstraintProto& operator=(const IntervalConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  IntervalConstraintProto(IntervalConstraintProto&& from) noexcept
    : IntervalConstraintProto() {
    *this = ::std::move(from);
  }

  inline IntervalConstraintProto& operator=(IntervalConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const IntervalConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IntervalConstraintProto* internal_default_instance() {
    return reinterpret_cast<const IntervalConstraintProto*>(
               &_IntervalConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(IntervalConstraintProto* other);
  friend void swap(IntervalConstraintProto& a, IntervalConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline IntervalConstraintProto* New() const final {
    return CreateMaybeMessage<IntervalConstraintProto>(nullptr);
  }

  IntervalConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<IntervalConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const IntervalConstraintProto& from);
  void MergeFrom(const IntervalConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(IntervalConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int32 start = 1;
  void clear_start();
  static const int kStartFieldNumber = 1;
  ::google::protobuf::int32 start() const;
  void set_start(::google::protobuf::int32 value);

  // int32 end = 2;
  void clear_end();
  static const int kEndFieldNumber = 2;
  ::google::protobuf::int32 end() const;
  void set_end(::google::protobuf::int32 value);

  // int32 size = 3;
  void clear_size();
  static const int kSizeFieldNumber = 3;
  ::google::protobuf::int32 size() const;
  void set_size(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.IntervalConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int32 start_;
  ::google::protobuf::int32 end_;
  ::google::protobuf::int32 size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class NoOverlapConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.NoOverlapConstraintProto) */ {
 public:
  NoOverlapConstraintProto();
  virtual ~NoOverlapConstraintProto();

  NoOverlapConstraintProto(const NoOverlapConstraintProto& from);

  inline NoOverlapConstraintProto& operator=(const NoOverlapConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NoOverlapConstraintProto(NoOverlapConstraintProto&& from) noexcept
    : NoOverlapConstraintProto() {
    *this = ::std::move(from);
  }

  inline NoOverlapConstraintProto& operator=(NoOverlapConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const NoOverlapConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NoOverlapConstraintProto* internal_default_instance() {
    return reinterpret_cast<const NoOverlapConstraintProto*>(
               &_NoOverlapConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void Swap(NoOverlapConstraintProto* other);
  friend void swap(NoOverlapConstraintProto& a, NoOverlapConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline NoOverlapConstraintProto* New() const final {
    return CreateMaybeMessage<NoOverlapConstraintProto>(nullptr);
  }

  NoOverlapConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NoOverlapConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const NoOverlapConstraintProto& from);
  void MergeFrom(const NoOverlapConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NoOverlapConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 intervals = 1;
  int intervals_size() const;
  void clear_intervals();
  static const int kIntervalsFieldNumber = 1;
  ::google::protobuf::int32 intervals(int index) const;
  void set_intervals(int index, ::google::protobuf::int32 value);
  void add_intervals(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      intervals() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_intervals();

  // @@protoc_insertion_point(class_scope:operations_research.sat.NoOverlapConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > intervals_;
  mutable std::atomic<int> _intervals_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class NoOverlap2DConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.NoOverlap2DConstraintProto) */ {
 public:
  NoOverlap2DConstraintProto();
  virtual ~NoOverlap2DConstraintProto();

  NoOverlap2DConstraintProto(const NoOverlap2DConstraintProto& from);

  inline NoOverlap2DConstraintProto& operator=(const NoOverlap2DConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NoOverlap2DConstraintProto(NoOverlap2DConstraintProto&& from) noexcept
    : NoOverlap2DConstraintProto() {
    *this = ::std::move(from);
  }

  inline NoOverlap2DConstraintProto& operator=(NoOverlap2DConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const NoOverlap2DConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NoOverlap2DConstraintProto* internal_default_instance() {
    return reinterpret_cast<const NoOverlap2DConstraintProto*>(
               &_NoOverlap2DConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void Swap(NoOverlap2DConstraintProto* other);
  friend void swap(NoOverlap2DConstraintProto& a, NoOverlap2DConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline NoOverlap2DConstraintProto* New() const final {
    return CreateMaybeMessage<NoOverlap2DConstraintProto>(nullptr);
  }

  NoOverlap2DConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NoOverlap2DConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const NoOverlap2DConstraintProto& from);
  void MergeFrom(const NoOverlap2DConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NoOverlap2DConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 x_intervals = 1;
  int x_intervals_size() const;
  void clear_x_intervals();
  static const int kXIntervalsFieldNumber = 1;
  ::google::protobuf::int32 x_intervals(int index) const;
  void set_x_intervals(int index, ::google::protobuf::int32 value);
  void add_x_intervals(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      x_intervals() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_x_intervals();

  // repeated int32 y_intervals = 2;
  int y_intervals_size() const;
  void clear_y_intervals();
  static const int kYIntervalsFieldNumber = 2;
  ::google::protobuf::int32 y_intervals(int index) const;
  void set_y_intervals(int index, ::google::protobuf::int32 value);
  void add_y_intervals(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      y_intervals() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_y_intervals();

  // @@protoc_insertion_point(class_scope:operations_research.sat.NoOverlap2DConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > x_intervals_;
  mutable std::atomic<int> _x_intervals_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > y_intervals_;
  mutable std::atomic<int> _y_intervals_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CumulativeConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CumulativeConstraintProto) */ {
 public:
  CumulativeConstraintProto();
  virtual ~CumulativeConstraintProto();

  CumulativeConstraintProto(const CumulativeConstraintProto& from);

  inline CumulativeConstraintProto& operator=(const CumulativeConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  CumulativeConstraintProto(CumulativeConstraintProto&& from) noexcept
    : CumulativeConstraintProto() {
    *this = ::std::move(from);
  }

  inline CumulativeConstraintProto& operator=(CumulativeConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const CumulativeConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CumulativeConstraintProto* internal_default_instance() {
    return reinterpret_cast<const CumulativeConstraintProto*>(
               &_CumulativeConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  void Swap(CumulativeConstraintProto* other);
  friend void swap(CumulativeConstraintProto& a, CumulativeConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline CumulativeConstraintProto* New() const final {
    return CreateMaybeMessage<CumulativeConstraintProto>(nullptr);
  }

  CumulativeConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<CumulativeConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const CumulativeConstraintProto& from);
  void MergeFrom(const CumulativeConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CumulativeConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 intervals = 2;
  int intervals_size() const;
  void clear_intervals();
  static const int kIntervalsFieldNumber = 2;
  ::google::protobuf::int32 intervals(int index) const;
  void set_intervals(int index, ::google::protobuf::int32 value);
  void add_intervals(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      intervals() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_intervals();

  // repeated int32 demands = 3;
  int demands_size() const;
  void clear_demands();
  static const int kDemandsFieldNumber = 3;
  ::google::protobuf::int32 demands(int index) const;
  void set_demands(int index, ::google::protobuf::int32 value);
  void add_demands(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      demands() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_demands();

  // int32 capacity = 1;
  void clear_capacity();
  static const int kCapacityFieldNumber = 1;
  ::google::protobuf::int32 capacity() const;
  void set_capacity(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.CumulativeConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > intervals_;
  mutable std::atomic<int> _intervals_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > demands_;
  mutable std::atomic<int> _demands_cached_byte_size_;
  ::google::protobuf::int32 capacity_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class ReservoirConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.ReservoirConstraintProto) */ {
 public:
  ReservoirConstraintProto();
  virtual ~ReservoirConstraintProto();

  ReservoirConstraintProto(const ReservoirConstraintProto& from);

  inline ReservoirConstraintProto& operator=(const ReservoirConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReservoirConstraintProto(ReservoirConstraintProto&& from) noexcept
    : ReservoirConstraintProto() {
    *this = ::std::move(from);
  }

  inline ReservoirConstraintProto& operator=(ReservoirConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const ReservoirConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReservoirConstraintProto* internal_default_instance() {
    return reinterpret_cast<const ReservoirConstraintProto*>(
               &_ReservoirConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  void Swap(ReservoirConstraintProto* other);
  friend void swap(ReservoirConstraintProto& a, ReservoirConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ReservoirConstraintProto* New() const final {
    return CreateMaybeMessage<ReservoirConstraintProto>(nullptr);
  }

  ReservoirConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReservoirConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ReservoirConstraintProto& from);
  void MergeFrom(const ReservoirConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReservoirConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 times = 3;
  int times_size() const;
  void clear_times();
  static const int kTimesFieldNumber = 3;
  ::google::protobuf::int32 times(int index) const;
  void set_times(int index, ::google::protobuf::int32 value);
  void add_times(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      times() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_times();

  // repeated int64 demands = 4;
  int demands_size() const;
  void clear_demands();
  static const int kDemandsFieldNumber = 4;
  ::google::protobuf::int64 demands(int index) const;
  void set_demands(int index, ::google::protobuf::int64 value);
  void add_demands(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      demands() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_demands();

  // repeated int32 actives = 5;
  int actives_size() const;
  void clear_actives();
  static const int kActivesFieldNumber = 5;
  ::google::protobuf::int32 actives(int index) const;
  void set_actives(int index, ::google::protobuf::int32 value);
  void add_actives(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      actives() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_actives();

  // int64 min_level = 1;
  void clear_min_level();
  static const int kMinLevelFieldNumber = 1;
  ::google::protobuf::int64 min_level() const;
  void set_min_level(::google::protobuf::int64 value);

  // int64 max_level = 2;
  void clear_max_level();
  static const int kMaxLevelFieldNumber = 2;
  ::google::protobuf::int64 max_level() const;
  void set_max_level(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.ReservoirConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > times_;
  mutable std::atomic<int> _times_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > demands_;
  mutable std::atomic<int> _demands_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > actives_;
  mutable std::atomic<int> _actives_cached_byte_size_;
  ::google::protobuf::int64 min_level_;
  ::google::protobuf::int64 max_level_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CircuitConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CircuitConstraintProto) */ {
 public:
  CircuitConstraintProto();
  virtual ~CircuitConstraintProto();

  CircuitConstraintProto(const CircuitConstraintProto& from);

  inline CircuitConstraintProto& operator=(const CircuitConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  CircuitConstraintProto(CircuitConstraintProto&& from) noexcept
    : CircuitConstraintProto() {
    *this = ::std::move(from);
  }

  inline CircuitConstraintProto& operator=(CircuitConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const CircuitConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CircuitConstraintProto* internal_default_instance() {
    return reinterpret_cast<const CircuitConstraintProto*>(
               &_CircuitConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  void Swap(CircuitConstraintProto* other);
  friend void swap(CircuitConstraintProto& a, CircuitConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline CircuitConstraintProto* New() const final {
    return CreateMaybeMessage<CircuitConstraintProto>(nullptr);
  }

  CircuitConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<CircuitConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const CircuitConstraintProto& from);
  void MergeFrom(const CircuitConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CircuitConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 tails = 3;
  int tails_size() const;
  void clear_tails();
  static const int kTailsFieldNumber = 3;
  ::google::protobuf::int32 tails(int index) const;
  void set_tails(int index, ::google::protobuf::int32 value);
  void add_tails(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      tails() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_tails();

  // repeated int32 heads = 4;
  int heads_size() const;
  void clear_heads();
  static const int kHeadsFieldNumber = 4;
  ::google::protobuf::int32 heads(int index) const;
  void set_heads(int index, ::google::protobuf::int32 value);
  void add_heads(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      heads() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_heads();

  // repeated int32 literals = 5;
  int literals_size() const;
  void clear_literals();
  static const int kLiteralsFieldNumber = 5;
  ::google::protobuf::int32 literals(int index) const;
  void set_literals(int index, ::google::protobuf::int32 value);
  void add_literals(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      literals() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_literals();

  // @@protoc_insertion_point(class_scope:operations_research.sat.CircuitConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > tails_;
  mutable std::atomic<int> _tails_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > heads_;
  mutable std::atomic<int> _heads_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > literals_;
  mutable std::atomic<int> _literals_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class RoutesConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.RoutesConstraintProto) */ {
 public:
  RoutesConstraintProto();
  virtual ~RoutesConstraintProto();

  RoutesConstraintProto(const RoutesConstraintProto& from);

  inline RoutesConstraintProto& operator=(const RoutesConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RoutesConstraintProto(RoutesConstraintProto&& from) noexcept
    : RoutesConstraintProto() {
    *this = ::std::move(from);
  }

  inline RoutesConstraintProto& operator=(RoutesConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const RoutesConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RoutesConstraintProto* internal_default_instance() {
    return reinterpret_cast<const RoutesConstraintProto*>(
               &_RoutesConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  void Swap(RoutesConstraintProto* other);
  friend void swap(RoutesConstraintProto& a, RoutesConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RoutesConstraintProto* New() const final {
    return CreateMaybeMessage<RoutesConstraintProto>(nullptr);
  }

  RoutesConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RoutesConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RoutesConstraintProto& from);
  void MergeFrom(const RoutesConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RoutesConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 tails = 1;
  int tails_size() const;
  void clear_tails();
  static const int kTailsFieldNumber = 1;
  ::google::protobuf::int32 tails(int index) const;
  void set_tails(int index, ::google::protobuf::int32 value);
  void add_tails(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      tails() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_tails();

  // repeated int32 heads = 2;
  int heads_size() const;
  void clear_heads();
  static const int kHeadsFieldNumber = 2;
  ::google::protobuf::int32 heads(int index) const;
  void set_heads(int index, ::google::protobuf::int32 value);
  void add_heads(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      heads() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_heads();

  // repeated int32 literals = 3;
  int literals_size() const;
  void clear_literals();
  static const int kLiteralsFieldNumber = 3;
  ::google::protobuf::int32 literals(int index) const;
  void set_literals(int index, ::google::protobuf::int32 value);
  void add_literals(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      literals() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_literals();

  // repeated int32 demands = 4;
  int demands_size() const;
  void clear_demands();
  static const int kDemandsFieldNumber = 4;
  ::google::protobuf::int32 demands(int index) const;
  void set_demands(int index, ::google::protobuf::int32 value);
  void add_demands(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      demands() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_demands();

  // int64 capacity = 5;
  void clear_capacity();
  static const int kCapacityFieldNumber = 5;
  ::google::protobuf::int64 capacity() const;
  void set_capacity(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.RoutesConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > tails_;
  mutable std::atomic<int> _tails_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > heads_;
  mutable std::atomic<int> _heads_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > literals_;
  mutable std::atomic<int> _literals_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > demands_;
  mutable std::atomic<int> _demands_cached_byte_size_;
  ::google::protobuf::int64 capacity_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CircuitCoveringConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CircuitCoveringConstraintProto) */ {
 public:
  CircuitCoveringConstraintProto();
  virtual ~CircuitCoveringConstraintProto();

  CircuitCoveringConstraintProto(const CircuitCoveringConstraintProto& from);

  inline CircuitCoveringConstraintProto& operator=(const CircuitCoveringConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  CircuitCoveringConstraintProto(CircuitCoveringConstraintProto&& from) noexcept
    : CircuitCoveringConstraintProto() {
    *this = ::std::move(from);
  }

  inline CircuitCoveringConstraintProto& operator=(CircuitCoveringConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const CircuitCoveringConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CircuitCoveringConstraintProto* internal_default_instance() {
    return reinterpret_cast<const CircuitCoveringConstraintProto*>(
               &_CircuitCoveringConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  void Swap(CircuitCoveringConstraintProto* other);
  friend void swap(CircuitCoveringConstraintProto& a, CircuitCoveringConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline CircuitCoveringConstraintProto* New() const final {
    return CreateMaybeMessage<CircuitCoveringConstraintProto>(nullptr);
  }

  CircuitCoveringConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<CircuitCoveringConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const CircuitCoveringConstraintProto& from);
  void MergeFrom(const CircuitCoveringConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CircuitCoveringConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 nexts = 1;
  int nexts_size() const;
  void clear_nexts();
  static const int kNextsFieldNumber = 1;
  ::google::protobuf::int32 nexts(int index) const;
  void set_nexts(int index, ::google::protobuf::int32 value);
  void add_nexts(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      nexts() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_nexts();

  // repeated int64 distinguished_nodes = 2;
  int distinguished_nodes_size() const;
  void clear_distinguished_nodes();
  static const int kDistinguishedNodesFieldNumber = 2;
  ::google::protobuf::int64 distinguished_nodes(int index) const;
  void set_distinguished_nodes(int index, ::google::protobuf::int64 value);
  void add_distinguished_nodes(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      distinguished_nodes() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_distinguished_nodes();

  // @@protoc_insertion_point(class_scope:operations_research.sat.CircuitCoveringConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > nexts_;
  mutable std::atomic<int> _nexts_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > distinguished_nodes_;
  mutable std::atomic<int> _distinguished_nodes_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class TableConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.TableConstraintProto) */ {
 public:
  TableConstraintProto();
  virtual ~TableConstraintProto();

  TableConstraintProto(const TableConstraintProto& from);

  inline TableConstraintProto& operator=(const TableConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TableConstraintProto(TableConstraintProto&& from) noexcept
    : TableConstraintProto() {
    *this = ::std::move(from);
  }

  inline TableConstraintProto& operator=(TableConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const TableConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TableConstraintProto* internal_default_instance() {
    return reinterpret_cast<const TableConstraintProto*>(
               &_TableConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  void Swap(TableConstraintProto* other);
  friend void swap(TableConstraintProto& a, TableConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline TableConstraintProto* New() const final {
    return CreateMaybeMessage<TableConstraintProto>(nullptr);
  }

  TableConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TableConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TableConstraintProto& from);
  void MergeFrom(const TableConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TableConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 vars = 1;
  int vars_size() const;
  void clear_vars();
  static const int kVarsFieldNumber = 1;
  ::google::protobuf::int32 vars(int index) const;
  void set_vars(int index, ::google::protobuf::int32 value);
  void add_vars(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vars() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vars();

  // repeated int64 values = 2;
  int values_size() const;
  void clear_values();
  static const int kValuesFieldNumber = 2;
  ::google::protobuf::int64 values(int index) const;
  void set_values(int index, ::google::protobuf::int64 value);
  void add_values(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      values() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_values();

  // bool negated = 3;
  void clear_negated();
  static const int kNegatedFieldNumber = 3;
  bool negated() const;
  void set_negated(bool value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.TableConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > values_;
  mutable std::atomic<int> _values_cached_byte_size_;
  bool negated_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class InverseConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.InverseConstraintProto) */ {
 public:
  InverseConstraintProto();
  virtual ~InverseConstraintProto();

  InverseConstraintProto(const InverseConstraintProto& from);

  inline InverseConstraintProto& operator=(const InverseConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  InverseConstraintProto(InverseConstraintProto&& from) noexcept
    : InverseConstraintProto() {
    *this = ::std::move(from);
  }

  inline InverseConstraintProto& operator=(InverseConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const InverseConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const InverseConstraintProto* internal_default_instance() {
    return reinterpret_cast<const InverseConstraintProto*>(
               &_InverseConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  void Swap(InverseConstraintProto* other);
  friend void swap(InverseConstraintProto& a, InverseConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline InverseConstraintProto* New() const final {
    return CreateMaybeMessage<InverseConstraintProto>(nullptr);
  }

  InverseConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<InverseConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const InverseConstraintProto& from);
  void MergeFrom(const InverseConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InverseConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 f_direct = 1;
  int f_direct_size() const;
  void clear_f_direct();
  static const int kFDirectFieldNumber = 1;
  ::google::protobuf::int32 f_direct(int index) const;
  void set_f_direct(int index, ::google::protobuf::int32 value);
  void add_f_direct(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      f_direct() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_f_direct();

  // repeated int32 f_inverse = 2;
  int f_inverse_size() const;
  void clear_f_inverse();
  static const int kFInverseFieldNumber = 2;
  ::google::protobuf::int32 f_inverse(int index) const;
  void set_f_inverse(int index, ::google::protobuf::int32 value);
  void add_f_inverse(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      f_inverse() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_f_inverse();

  // @@protoc_insertion_point(class_scope:operations_research.sat.InverseConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > f_direct_;
  mutable std::atomic<int> _f_direct_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > f_inverse_;
  mutable std::atomic<int> _f_inverse_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class AutomatonConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.AutomatonConstraintProto) */ {
 public:
  AutomatonConstraintProto();
  virtual ~AutomatonConstraintProto();

  AutomatonConstraintProto(const AutomatonConstraintProto& from);

  inline AutomatonConstraintProto& operator=(const AutomatonConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  AutomatonConstraintProto(AutomatonConstraintProto&& from) noexcept
    : AutomatonConstraintProto() {
    *this = ::std::move(from);
  }

  inline AutomatonConstraintProto& operator=(AutomatonConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const AutomatonConstraintProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const AutomatonConstraintProto* internal_default_instance() {
    return reinterpret_cast<const AutomatonConstraintProto*>(
               &_AutomatonConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  void Swap(AutomatonConstraintProto* other);
  friend void swap(AutomatonConstraintProto& a, AutomatonConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline AutomatonConstraintProto* New() const final {
    return CreateMaybeMessage<AutomatonConstraintProto>(nullptr);
  }

  AutomatonConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<AutomatonConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const AutomatonConstraintProto& from);
  void MergeFrom(const AutomatonConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AutomatonConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int64 final_states = 3;
  int final_states_size() const;
  void clear_final_states();
  static const int kFinalStatesFieldNumber = 3;
  ::google::protobuf::int64 final_states(int index) const;
  void set_final_states(int index, ::google::protobuf::int64 value);
  void add_final_states(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      final_states() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_final_states();

  // repeated int64 transition_tail = 4;
  int transition_tail_size() const;
  void clear_transition_tail();
  static const int kTransitionTailFieldNumber = 4;
  ::google::protobuf::int64 transition_tail(int index) const;
  void set_transition_tail(int index, ::google::protobuf::int64 value);
  void add_transition_tail(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      transition_tail() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_transition_tail();

  // repeated int64 transition_head = 5;
  int transition_head_size() const;
  void clear_transition_head();
  static const int kTransitionHeadFieldNumber = 5;
  ::google::protobuf::int64 transition_head(int index) const;
  void set_transition_head(int index, ::google::protobuf::int64 value);
  void add_transition_head(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      transition_head() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_transition_head();

  // repeated int64 transition_label = 6;
  int transition_label_size() const;
  void clear_transition_label();
  static const int kTransitionLabelFieldNumber = 6;
  ::google::protobuf::int64 transition_label(int index) const;
  void set_transition_label(int index, ::google::protobuf::int64 value);
  void add_transition_label(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      transition_label() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_transition_label();

  // repeated int32 vars = 7;
  int vars_size() const;
  void clear_vars();
  static const int kVarsFieldNumber = 7;
  ::google::protobuf::int32 vars(int index) const;
  void set_vars(int index, ::google::protobuf::int32 value);
  void add_vars(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vars() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vars();

  // int64 starting_state = 2;
  void clear_starting_state();
  static const int kStartingStateFieldNumber = 2;
  ::google::protobuf::int64 starting_state() const;
  void set_starting_state(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.AutomatonConstraintProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > final_states_;
  mutable std::atomic<int> _final_states_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > transition_tail_;
  mutable std::atomic<int> _transition_tail_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > transition_head_;
  mutable std::atomic<int> _transition_head_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > transition_label_;
  mutable std::atomic<int> _transition_label_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::google::protobuf::int64 starting_state_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class ConstraintProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.ConstraintProto) */ {
 public:
  ConstraintProto();
  virtual ~ConstraintProto();

  ConstraintProto(const ConstraintProto& from);

  inline ConstraintProto& operator=(const ConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ConstraintProto(ConstraintProto&& from) noexcept
    : ConstraintProto() {
    *this = ::std::move(from);
  }

  inline ConstraintProto& operator=(ConstraintProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const ConstraintProto& default_instance();

  enum ConstraintCase {
    kBoolOr = 3,
    kBoolAnd = 4,
    kAtMostOne = 26,
    kBoolXor = 5,
    kIntDiv = 7,
    kIntMod = 8,
    kIntMax = 9,
    kIntMin = 10,
    kIntProd = 11,
    kLinear = 12,
    kAllDiff = 13,
    kElement = 14,
    kCircuit = 15,
    kRoutes = 23,
    kCircuitCovering = 25,
    kTable = 16,
    kAutomaton = 17,
    kInverse = 18,
    kReservoir = 24,
    kInterval = 19,
    kNoOverlap = 20,
    kNoOverlap2D = 21,
    kCumulative = 22,
    CONSTRAINT_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConstraintProto* internal_default_instance() {
    return reinterpret_cast<const ConstraintProto*>(
               &_ConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  void Swap(ConstraintProto* other);
  friend void swap(ConstraintProto& a, ConstraintProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ConstraintProto* New() const final {
    return CreateMaybeMessage<ConstraintProto>(nullptr);
  }

  ConstraintProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ConstraintProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ConstraintProto& from);
  void MergeFrom(const ConstraintProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ConstraintProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 enforcement_literal = 2;
  int enforcement_literal_size() const;
  void clear_enforcement_literal();
  static const int kEnforcementLiteralFieldNumber = 2;
  ::google::protobuf::int32 enforcement_literal(int index) const;
  void set_enforcement_literal(int index, ::google::protobuf::int32 value);
  void add_enforcement_literal(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      enforcement_literal() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_enforcement_literal();

  // string name = 1;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // .operations_research.sat.BoolArgumentProto bool_or = 3;
  bool has_bool_or() const;
  void clear_bool_or();
  static const int kBoolOrFieldNumber = 3;
  const ::operations_research::sat::BoolArgumentProto& bool_or() const;
  ::operations_research::sat::BoolArgumentProto* release_bool_or();
  ::operations_research::sat::BoolArgumentProto* mutable_bool_or();
  void set_allocated_bool_or(::operations_research::sat::BoolArgumentProto* bool_or);

  // .operations_research.sat.BoolArgumentProto bool_and = 4;
  bool has_bool_and() const;
  void clear_bool_and();
  static const int kBoolAndFieldNumber = 4;
  const ::operations_research::sat::BoolArgumentProto& bool_and() const;
  ::operations_research::sat::BoolArgumentProto* release_bool_and();
  ::operations_research::sat::BoolArgumentProto* mutable_bool_and();
  void set_allocated_bool_and(::operations_research::sat::BoolArgumentProto* bool_and);

  // .operations_research.sat.BoolArgumentProto at_most_one = 26;
  bool has_at_most_one() const;
  void clear_at_most_one();
  static const int kAtMostOneFieldNumber = 26;
  const ::operations_research::sat::BoolArgumentProto& at_most_one() const;
  ::operations_research::sat::BoolArgumentProto* release_at_most_one();
  ::operations_research::sat::BoolArgumentProto* mutable_at_most_one();
  void set_allocated_at_most_one(::operations_research::sat::BoolArgumentProto* at_most_one);

  // .operations_research.sat.BoolArgumentProto bool_xor = 5;
  bool has_bool_xor() const;
  void clear_bool_xor();
  static const int kBoolXorFieldNumber = 5;
  const ::operations_research::sat::BoolArgumentProto& bool_xor() const;
  ::operations_research::sat::BoolArgumentProto* release_bool_xor();
  ::operations_research::sat::BoolArgumentProto* mutable_bool_xor();
  void set_allocated_bool_xor(::operations_research::sat::BoolArgumentProto* bool_xor);

  // .operations_research.sat.IntegerArgumentProto int_div = 7;
  bool has_int_div() const;
  void clear_int_div();
  static const int kIntDivFieldNumber = 7;
  const ::operations_research::sat::IntegerArgumentProto& int_div() const;
  ::operations_research::sat::IntegerArgumentProto* release_int_div();
  ::operations_research::sat::IntegerArgumentProto* mutable_int_div();
  void set_allocated_int_div(::operations_research::sat::IntegerArgumentProto* int_div);

  // .operations_research.sat.IntegerArgumentProto int_mod = 8;
  bool has_int_mod() const;
  void clear_int_mod();
  static const int kIntModFieldNumber = 8;
  const ::operations_research::sat::IntegerArgumentProto& int_mod() const;
  ::operations_research::sat::IntegerArgumentProto* release_int_mod();
  ::operations_research::sat::IntegerArgumentProto* mutable_int_mod();
  void set_allocated_int_mod(::operations_research::sat::IntegerArgumentProto* int_mod);

  // .operations_research.sat.IntegerArgumentProto int_max = 9;
  bool has_int_max() const;
  void clear_int_max();
  static const int kIntMaxFieldNumber = 9;
  const ::operations_research::sat::IntegerArgumentProto& int_max() const;
  ::operations_research::sat::IntegerArgumentProto* release_int_max();
  ::operations_research::sat::IntegerArgumentProto* mutable_int_max();
  void set_allocated_int_max(::operations_research::sat::IntegerArgumentProto* int_max);

  // .operations_research.sat.IntegerArgumentProto int_min = 10;
  bool has_int_min() const;
  void clear_int_min();
  static const int kIntMinFieldNumber = 10;
  const ::operations_research::sat::IntegerArgumentProto& int_min() const;
  ::operations_research::sat::IntegerArgumentProto* release_int_min();
  ::operations_research::sat::IntegerArgumentProto* mutable_int_min();
  void set_allocated_int_min(::operations_research::sat::IntegerArgumentProto* int_min);

  // .operations_research.sat.IntegerArgumentProto int_prod = 11;
  bool has_int_prod() const;
  void clear_int_prod();
  static const int kIntProdFieldNumber = 11;
  const ::operations_research::sat::IntegerArgumentProto& int_prod() const;
  ::operations_research::sat::IntegerArgumentProto* release_int_prod();
  ::operations_research::sat::IntegerArgumentProto* mutable_int_prod();
  void set_allocated_int_prod(::operations_research::sat::IntegerArgumentProto* int_prod);

  // .operations_research.sat.LinearConstraintProto linear = 12;
  bool has_linear() const;
  void clear_linear();
  static const int kLinearFieldNumber = 12;
  const ::operations_research::sat::LinearConstraintProto& linear() const;
  ::operations_research::sat::LinearConstraintProto* release_linear();
  ::operations_research::sat::LinearConstraintProto* mutable_linear();
  void set_allocated_linear(::operations_research::sat::LinearConstraintProto* linear);

  // .operations_research.sat.AllDifferentConstraintProto all_diff = 13;
  bool has_all_diff() const;
  void clear_all_diff();
  static const int kAllDiffFieldNumber = 13;
  const ::operations_research::sat::AllDifferentConstraintProto& all_diff() const;
  ::operations_research::sat::AllDifferentConstraintProto* release_all_diff();
  ::operations_research::sat::AllDifferentConstraintProto* mutable_all_diff();
  void set_allocated_all_diff(::operations_research::sat::AllDifferentConstraintProto* all_diff);

  // .operations_research.sat.ElementConstraintProto element = 14;
  bool has_element() const;
  void clear_element();
  static const int kElementFieldNumber = 14;
  const ::operations_research::sat::ElementConstraintProto& element() const;
  ::operations_research::sat::ElementConstraintProto* release_element();
  ::operations_research::sat::ElementConstraintProto* mutable_element();
  void set_allocated_element(::operations_research::sat::ElementConstraintProto* element);

  // .operations_research.sat.CircuitConstraintProto circuit = 15;
  bool has_circuit() const;
  void clear_circuit();
  static const int kCircuitFieldNumber = 15;
  const ::operations_research::sat::CircuitConstraintProto& circuit() const;
  ::operations_research::sat::CircuitConstraintProto* release_circuit();
  ::operations_research::sat::CircuitConstraintProto* mutable_circuit();
  void set_allocated_circuit(::operations_research::sat::CircuitConstraintProto* circuit);

  // .operations_research.sat.RoutesConstraintProto routes = 23;
  bool has_routes() const;
  void clear_routes();
  static const int kRoutesFieldNumber = 23;
  const ::operations_research::sat::RoutesConstraintProto& routes() const;
  ::operations_research::sat::RoutesConstraintProto* release_routes();
  ::operations_research::sat::RoutesConstraintProto* mutable_routes();
  void set_allocated_routes(::operations_research::sat::RoutesConstraintProto* routes);

  // .operations_research.sat.CircuitCoveringConstraintProto circuit_covering = 25;
  bool has_circuit_covering() const;
  void clear_circuit_covering();
  static const int kCircuitCoveringFieldNumber = 25;
  const ::operations_research::sat::CircuitCoveringConstraintProto& circuit_covering() const;
  ::operations_research::sat::CircuitCoveringConstraintProto* release_circuit_covering();
  ::operations_research::sat::CircuitCoveringConstraintProto* mutable_circuit_covering();
  void set_allocated_circuit_covering(::operations_research::sat::CircuitCoveringConstraintProto* circuit_covering);

  // .operations_research.sat.TableConstraintProto table = 16;
  bool has_table() const;
  void clear_table();
  static const int kTableFieldNumber = 16;
  const ::operations_research::sat::TableConstraintProto& table() const;
  ::operations_research::sat::TableConstraintProto* release_table();
  ::operations_research::sat::TableConstraintProto* mutable_table();
  void set_allocated_table(::operations_research::sat::TableConstraintProto* table);

  // .operations_research.sat.AutomatonConstraintProto automaton = 17;
  bool has_automaton() const;
  void clear_automaton();
  static const int kAutomatonFieldNumber = 17;
  const ::operations_research::sat::AutomatonConstraintProto& automaton() const;
  ::operations_research::sat::AutomatonConstraintProto* release_automaton();
  ::operations_research::sat::AutomatonConstraintProto* mutable_automaton();
  void set_allocated_automaton(::operations_research::sat::AutomatonConstraintProto* automaton);

  // .operations_research.sat.InverseConstraintProto inverse = 18;
  bool has_inverse() const;
  void clear_inverse();
  static const int kInverseFieldNumber = 18;
  const ::operations_research::sat::InverseConstraintProto& inverse() const;
  ::operations_research::sat::InverseConstraintProto* release_inverse();
  ::operations_research::sat::InverseConstraintProto* mutable_inverse();
  void set_allocated_inverse(::operations_research::sat::InverseConstraintProto* inverse);

  // .operations_research.sat.ReservoirConstraintProto reservoir = 24;
  bool has_reservoir() const;
  void clear_reservoir();
  static const int kReservoirFieldNumber = 24;
  const ::operations_research::sat::ReservoirConstraintProto& reservoir() const;
  ::operations_research::sat::ReservoirConstraintProto* release_reservoir();
  ::operations_research::sat::ReservoirConstraintProto* mutable_reservoir();
  void set_allocated_reservoir(::operations_research::sat::ReservoirConstraintProto* reservoir);

  // .operations_research.sat.IntervalConstraintProto interval = 19;
  bool has_interval() const;
  void clear_interval();
  static const int kIntervalFieldNumber = 19;
  const ::operations_research::sat::IntervalConstraintProto& interval() const;
  ::operations_research::sat::IntervalConstraintProto* release_interval();
  ::operations_research::sat::IntervalConstraintProto* mutable_interval();
  void set_allocated_interval(::operations_research::sat::IntervalConstraintProto* interval);

  // .operations_research.sat.NoOverlapConstraintProto no_overlap = 20;
  bool has_no_overlap() const;
  void clear_no_overlap();
  static const int kNoOverlapFieldNumber = 20;
  const ::operations_research::sat::NoOverlapConstraintProto& no_overlap() const;
  ::operations_research::sat::NoOverlapConstraintProto* release_no_overlap();
  ::operations_research::sat::NoOverlapConstraintProto* mutable_no_overlap();
  void set_allocated_no_overlap(::operations_research::sat::NoOverlapConstraintProto* no_overlap);

  // .operations_research.sat.NoOverlap2DConstraintProto no_overlap_2d = 21;
  bool has_no_overlap_2d() const;
  void clear_no_overlap_2d();
  static const int kNoOverlap2DFieldNumber = 21;
  const ::operations_research::sat::NoOverlap2DConstraintProto& no_overlap_2d() const;
  ::operations_research::sat::NoOverlap2DConstraintProto* release_no_overlap_2d();
  ::operations_research::sat::NoOverlap2DConstraintProto* mutable_no_overlap_2d();
  void set_allocated_no_overlap_2d(::operations_research::sat::NoOverlap2DConstraintProto* no_overlap_2d);

  // .operations_research.sat.CumulativeConstraintProto cumulative = 22;
  bool has_cumulative() const;
  void clear_cumulative();
  static const int kCumulativeFieldNumber = 22;
  const ::operations_research::sat::CumulativeConstraintProto& cumulative() const;
  ::operations_research::sat::CumulativeConstraintProto* release_cumulative();
  ::operations_research::sat::CumulativeConstraintProto* mutable_cumulative();
  void set_allocated_cumulative(::operations_research::sat::CumulativeConstraintProto* cumulative);

  void clear_constraint();
  ConstraintCase constraint_case() const;
  // @@protoc_insertion_point(class_scope:operations_research.sat.ConstraintProto)
 private:
  class HasBitSetters;
  void set_has_bool_or();
  void set_has_bool_and();
  void set_has_at_most_one();
  void set_has_bool_xor();
  void set_has_int_div();
  void set_has_int_mod();
  void set_has_int_max();
  void set_has_int_min();
  void set_has_int_prod();
  void set_has_linear();
  void set_has_all_diff();
  void set_has_element();
  void set_has_circuit();
  void set_has_routes();
  void set_has_circuit_covering();
  void set_has_table();
  void set_has_automaton();
  void set_has_inverse();
  void set_has_reservoir();
  void set_has_interval();
  void set_has_no_overlap();
  void set_has_no_overlap_2d();
  void set_has_cumulative();

  inline bool has_constraint() const;
  inline void clear_has_constraint();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > enforcement_literal_;
  mutable std::atomic<int> _enforcement_literal_cached_byte_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  union ConstraintUnion {
    ConstraintUnion() {}
    ::operations_research::sat::BoolArgumentProto* bool_or_;
    ::operations_research::sat::BoolArgumentProto* bool_and_;
    ::operations_research::sat::BoolArgumentProto* at_most_one_;
    ::operations_research::sat::BoolArgumentProto* bool_xor_;
    ::operations_research::sat::IntegerArgumentProto* int_div_;
    ::operations_research::sat::IntegerArgumentProto* int_mod_;
    ::operations_research::sat::IntegerArgumentProto* int_max_;
    ::operations_research::sat::IntegerArgumentProto* int_min_;
    ::operations_research::sat::IntegerArgumentProto* int_prod_;
    ::operations_research::sat::LinearConstraintProto* linear_;
    ::operations_research::sat::AllDifferentConstraintProto* all_diff_;
    ::operations_research::sat::ElementConstraintProto* element_;
    ::operations_research::sat::CircuitConstraintProto* circuit_;
    ::operations_research::sat::RoutesConstraintProto* routes_;
    ::operations_research::sat::CircuitCoveringConstraintProto* circuit_covering_;
    ::operations_research::sat::TableConstraintProto* table_;
    ::operations_research::sat::AutomatonConstraintProto* automaton_;
    ::operations_research::sat::InverseConstraintProto* inverse_;
    ::operations_research::sat::ReservoirConstraintProto* reservoir_;
    ::operations_research::sat::IntervalConstraintProto* interval_;
    ::operations_research::sat::NoOverlapConstraintProto* no_overlap_;
    ::operations_research::sat::NoOverlap2DConstraintProto* no_overlap_2d_;
    ::operations_research::sat::CumulativeConstraintProto* cumulative_;
  } constraint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CpObjectiveProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CpObjectiveProto) */ {
 public:
  CpObjectiveProto();
  virtual ~CpObjectiveProto();

  CpObjectiveProto(const CpObjectiveProto& from);

  inline CpObjectiveProto& operator=(const CpObjectiveProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  CpObjectiveProto(CpObjectiveProto&& from) noexcept
    : CpObjectiveProto() {
    *this = ::std::move(from);
  }

  inline CpObjectiveProto& operator=(CpObjectiveProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const CpObjectiveProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CpObjectiveProto* internal_default_instance() {
    return reinterpret_cast<const CpObjectiveProto*>(
               &_CpObjectiveProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  void Swap(CpObjectiveProto* other);
  friend void swap(CpObjectiveProto& a, CpObjectiveProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline CpObjectiveProto* New() const final {
    return CreateMaybeMessage<CpObjectiveProto>(nullptr);
  }

  CpObjectiveProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<CpObjectiveProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const CpObjectiveProto& from);
  void MergeFrom(const CpObjectiveProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CpObjectiveProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 vars = 1;
  int vars_size() const;
  void clear_vars();
  static const int kVarsFieldNumber = 1;
  ::google::protobuf::int32 vars(int index) const;
  void set_vars(int index, ::google::protobuf::int32 value);
  void add_vars(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vars() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vars();

  // repeated int64 coeffs = 4;
  int coeffs_size() const;
  void clear_coeffs();
  static const int kCoeffsFieldNumber = 4;
  ::google::protobuf::int64 coeffs(int index) const;
  void set_coeffs(int index, ::google::protobuf::int64 value);
  void add_coeffs(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      coeffs() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_coeffs();

  // repeated int64 domain = 5;
  int domain_size() const;
  void clear_domain();
  static const int kDomainFieldNumber = 5;
  ::google::protobuf::int64 domain(int index) const;
  void set_domain(int index, ::google::protobuf::int64 value);
  void add_domain(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      domain() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_domain();

  // double offset = 2;
  void clear_offset();
  static const int kOffsetFieldNumber = 2;
  double offset() const;
  void set_offset(double value);

  // double scaling_factor = 3;
  void clear_scaling_factor();
  static const int kScalingFactorFieldNumber = 3;
  double scaling_factor() const;
  void set_scaling_factor(double value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.CpObjectiveProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > coeffs_;
  mutable std::atomic<int> _coeffs_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > domain_;
  mutable std::atomic<int> _domain_cached_byte_size_;
  double offset_;
  double scaling_factor_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class DecisionStrategyProto_AffineTransformation :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.DecisionStrategyProto.AffineTransformation) */ {
 public:
  DecisionStrategyProto_AffineTransformation();
  virtual ~DecisionStrategyProto_AffineTransformation();

  DecisionStrategyProto_AffineTransformation(const DecisionStrategyProto_AffineTransformation& from);

  inline DecisionStrategyProto_AffineTransformation& operator=(const DecisionStrategyProto_AffineTransformation& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  DecisionStrategyProto_AffineTransformation(DecisionStrategyProto_AffineTransformation&& from) noexcept
    : DecisionStrategyProto_AffineTransformation() {
    *this = ::std::move(from);
  }

  inline DecisionStrategyProto_AffineTransformation& operator=(DecisionStrategyProto_AffineTransformation&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const DecisionStrategyProto_AffineTransformation& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DecisionStrategyProto_AffineTransformation* internal_default_instance() {
    return reinterpret_cast<const DecisionStrategyProto_AffineTransformation*>(
               &_DecisionStrategyProto_AffineTransformation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  void Swap(DecisionStrategyProto_AffineTransformation* other);
  friend void swap(DecisionStrategyProto_AffineTransformation& a, DecisionStrategyProto_AffineTransformation& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline DecisionStrategyProto_AffineTransformation* New() const final {
    return CreateMaybeMessage<DecisionStrategyProto_AffineTransformation>(nullptr);
  }

  DecisionStrategyProto_AffineTransformation* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<DecisionStrategyProto_AffineTransformation>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const DecisionStrategyProto_AffineTransformation& from);
  void MergeFrom(const DecisionStrategyProto_AffineTransformation& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DecisionStrategyProto_AffineTransformation* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 offset = 2;
  void clear_offset();
  static const int kOffsetFieldNumber = 2;
  ::google::protobuf::int64 offset() const;
  void set_offset(::google::protobuf::int64 value);

  // int64 positive_coeff = 3;
  void clear_positive_coeff();
  static const int kPositiveCoeffFieldNumber = 3;
  ::google::protobuf::int64 positive_coeff() const;
  void set_positive_coeff(::google::protobuf::int64 value);

  // int32 var = 1;
  void clear_var();
  static const int kVarFieldNumber = 1;
  ::google::protobuf::int32 var() const;
  void set_var(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.DecisionStrategyProto.AffineTransformation)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 offset_;
  ::google::protobuf::int64 positive_coeff_;
  ::google::protobuf::int32 var_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class DecisionStrategyProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.DecisionStrategyProto) */ {
 public:
  DecisionStrategyProto();
  virtual ~DecisionStrategyProto();

  DecisionStrategyProto(const DecisionStrategyProto& from);

  inline DecisionStrategyProto& operator=(const DecisionStrategyProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  DecisionStrategyProto(DecisionStrategyProto&& from) noexcept
    : DecisionStrategyProto() {
    *this = ::std::move(from);
  }

  inline DecisionStrategyProto& operator=(DecisionStrategyProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const DecisionStrategyProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const DecisionStrategyProto* internal_default_instance() {
    return reinterpret_cast<const DecisionStrategyProto*>(
               &_DecisionStrategyProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  void Swap(DecisionStrategyProto* other);
  friend void swap(DecisionStrategyProto& a, DecisionStrategyProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline DecisionStrategyProto* New() const final {
    return CreateMaybeMessage<DecisionStrategyProto>(nullptr);
  }

  DecisionStrategyProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<DecisionStrategyProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const DecisionStrategyProto& from);
  void MergeFrom(const DecisionStrategyProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DecisionStrategyProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef DecisionStrategyProto_AffineTransformation AffineTransformation;

  typedef DecisionStrategyProto_VariableSelectionStrategy VariableSelectionStrategy;
  static const VariableSelectionStrategy CHOOSE_FIRST =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_FIRST;
  static const VariableSelectionStrategy CHOOSE_LOWEST_MIN =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_LOWEST_MIN;
  static const VariableSelectionStrategy CHOOSE_HIGHEST_MAX =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_HIGHEST_MAX;
  static const VariableSelectionStrategy CHOOSE_MIN_DOMAIN_SIZE =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_MIN_DOMAIN_SIZE;
  static const VariableSelectionStrategy CHOOSE_MAX_DOMAIN_SIZE =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_MAX_DOMAIN_SIZE;
  static inline bool VariableSelectionStrategy_IsValid(int value) {
    return DecisionStrategyProto_VariableSelectionStrategy_IsValid(value);
  }
  static const VariableSelectionStrategy VariableSelectionStrategy_MIN =
    DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MIN;
  static const VariableSelectionStrategy VariableSelectionStrategy_MAX =
    DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MAX;
  static const int VariableSelectionStrategy_ARRAYSIZE =
    DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  VariableSelectionStrategy_descriptor() {
    return DecisionStrategyProto_VariableSelectionStrategy_descriptor();
  }
  static inline const ::std::string& VariableSelectionStrategy_Name(VariableSelectionStrategy value) {
    return DecisionStrategyProto_VariableSelectionStrategy_Name(value);
  }
  static inline bool VariableSelectionStrategy_Parse(const ::std::string& name,
      VariableSelectionStrategy* value) {
    return DecisionStrategyProto_VariableSelectionStrategy_Parse(name, value);
  }

  typedef DecisionStrategyProto_DomainReductionStrategy DomainReductionStrategy;
  static const DomainReductionStrategy SELECT_MIN_VALUE =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_MIN_VALUE;
  static const DomainReductionStrategy SELECT_MAX_VALUE =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_MAX_VALUE;
  static const DomainReductionStrategy SELECT_LOWER_HALF =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_LOWER_HALF;
  static const DomainReductionStrategy SELECT_UPPER_HALF =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_UPPER_HALF;
  static inline bool DomainReductionStrategy_IsValid(int value) {
    return DecisionStrategyProto_DomainReductionStrategy_IsValid(value);
  }
  static const DomainReductionStrategy DomainReductionStrategy_MIN =
    DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MIN;
  static const DomainReductionStrategy DomainReductionStrategy_MAX =
    DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MAX;
  static const int DomainReductionStrategy_ARRAYSIZE =
    DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  DomainReductionStrategy_descriptor() {
    return DecisionStrategyProto_DomainReductionStrategy_descriptor();
  }
  static inline const ::std::string& DomainReductionStrategy_Name(DomainReductionStrategy value) {
    return DecisionStrategyProto_DomainReductionStrategy_Name(value);
  }
  static inline bool DomainReductionStrategy_Parse(const ::std::string& name,
      DomainReductionStrategy* value) {
    return DecisionStrategyProto_DomainReductionStrategy_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // repeated int32 variables = 1;
  int variables_size() const;
  void clear_variables();
  static const int kVariablesFieldNumber = 1;
  ::google::protobuf::int32 variables(int index) const;
  void set_variables(int index, ::google::protobuf::int32 value);
  void add_variables(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      variables() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_variables();

  // repeated .operations_research.sat.DecisionStrategyProto.AffineTransformation transformations = 4;
  int transformations_size() const;
  void clear_transformations();
  static const int kTransformationsFieldNumber = 4;
  ::operations_research::sat::DecisionStrategyProto_AffineTransformation* mutable_transformations(int index);
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto_AffineTransformation >*
      mutable_transformations();
  const ::operations_research::sat::DecisionStrategyProto_AffineTransformation& transformations(int index) const;
  ::operations_research::sat::DecisionStrategyProto_AffineTransformation* add_transformations();
  const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto_AffineTransformation >&
      transformations() const;

  // .operations_research.sat.DecisionStrategyProto.VariableSelectionStrategy variable_selection_strategy = 2;
  void clear_variable_selection_strategy();
  static const int kVariableSelectionStrategyFieldNumber = 2;
  ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy variable_selection_strategy() const;
  void set_variable_selection_strategy(::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy value);

  // .operations_research.sat.DecisionStrategyProto.DomainReductionStrategy domain_reduction_strategy = 3;
  void clear_domain_reduction_strategy();
  static const int kDomainReductionStrategyFieldNumber = 3;
  ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy domain_reduction_strategy() const;
  void set_domain_reduction_strategy(::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.DecisionStrategyProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > variables_;
  mutable std::atomic<int> _variables_cached_byte_size_;
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto_AffineTransformation > transformations_;
  int variable_selection_strategy_;
  int domain_reduction_strategy_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class PartialVariableAssignment :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.PartialVariableAssignment) */ {
 public:
  PartialVariableAssignment();
  virtual ~PartialVariableAssignment();

  PartialVariableAssignment(const PartialVariableAssignment& from);

  inline PartialVariableAssignment& operator=(const PartialVariableAssignment& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  PartialVariableAssignment(PartialVariableAssignment&& from) noexcept
    : PartialVariableAssignment() {
    *this = ::std::move(from);
  }

  inline PartialVariableAssignment& operator=(PartialVariableAssignment&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const PartialVariableAssignment& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const PartialVariableAssignment* internal_default_instance() {
    return reinterpret_cast<const PartialVariableAssignment*>(
               &_PartialVariableAssignment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  void Swap(PartialVariableAssignment* other);
  friend void swap(PartialVariableAssignment& a, PartialVariableAssignment& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline PartialVariableAssignment* New() const final {
    return CreateMaybeMessage<PartialVariableAssignment>(nullptr);
  }

  PartialVariableAssignment* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<PartialVariableAssignment>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const PartialVariableAssignment& from);
  void MergeFrom(const PartialVariableAssignment& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(PartialVariableAssignment* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int32 vars = 1;
  int vars_size() const;
  void clear_vars();
  static const int kVarsFieldNumber = 1;
  ::google::protobuf::int32 vars(int index) const;
  void set_vars(int index, ::google::protobuf::int32 value);
  void add_vars(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      vars() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_vars();

  // repeated int64 values = 2;
  int values_size() const;
  void clear_values();
  static const int kValuesFieldNumber = 2;
  ::google::protobuf::int64 values(int index) const;
  void set_values(int index, ::google::protobuf::int64 value);
  void add_values(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      values() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_values();

  // @@protoc_insertion_point(class_scope:operations_research.sat.PartialVariableAssignment)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > values_;
  mutable std::atomic<int> _values_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CpModelProto :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CpModelProto) */ {
 public:
  CpModelProto();
  virtual ~CpModelProto();

  CpModelProto(const CpModelProto& from);

  inline CpModelProto& operator=(const CpModelProto& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  CpModelProto(CpModelProto&& from) noexcept
    : CpModelProto() {
    *this = ::std::move(from);
  }

  inline CpModelProto& operator=(CpModelProto&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const CpModelProto& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CpModelProto* internal_default_instance() {
    return reinterpret_cast<const CpModelProto*>(
               &_CpModelProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  void Swap(CpModelProto* other);
  friend void swap(CpModelProto& a, CpModelProto& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline CpModelProto* New() const final {
    return CreateMaybeMessage<CpModelProto>(nullptr);
  }

  CpModelProto* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<CpModelProto>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const CpModelProto& from);
  void MergeFrom(const CpModelProto& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CpModelProto* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .operations_research.sat.IntegerVariableProto variables = 2;
  int variables_size() const;
  void clear_variables();
  static const int kVariablesFieldNumber = 2;
  ::operations_research::sat::IntegerVariableProto* mutable_variables(int index);
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >*
      mutable_variables();
  const ::operations_research::sat::IntegerVariableProto& variables(int index) const;
  ::operations_research::sat::IntegerVariableProto* add_variables();
  const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >&
      variables() const;

  // repeated .operations_research.sat.ConstraintProto constraints = 3;
  int constraints_size() const;
  void clear_constraints();
  static const int kConstraintsFieldNumber = 3;
  ::operations_research::sat::ConstraintProto* mutable_constraints(int index);
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::ConstraintProto >*
      mutable_constraints();
  const ::operations_research::sat::ConstraintProto& constraints(int index) const;
  ::operations_research::sat::ConstraintProto* add_constraints();
  const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::ConstraintProto >&
      constraints() const;

  // repeated .operations_research.sat.DecisionStrategyProto search_strategy = 5;
  int search_strategy_size() const;
  void clear_search_strategy();
  static const int kSearchStrategyFieldNumber = 5;
  ::operations_research::sat::DecisionStrategyProto* mutable_search_strategy(int index);
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto >*
      mutable_search_strategy();
  const ::operations_research::sat::DecisionStrategyProto& search_strategy(int index) const;
  ::operations_research::sat::DecisionStrategyProto* add_search_strategy();
  const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto >&
      search_strategy() const;

  // string name = 1;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // .operations_research.sat.CpObjectiveProto objective = 4;
  bool has_objective() const;
  void clear_objective();
  static const int kObjectiveFieldNumber = 4;
  const ::operations_research::sat::CpObjectiveProto& objective() const;
  ::operations_research::sat::CpObjectiveProto* release_objective();
  ::operations_research::sat::CpObjectiveProto* mutable_objective();
  void set_allocated_objective(::operations_research::sat::CpObjectiveProto* objective);

  // .operations_research.sat.PartialVariableAssignment solution_hint = 6;
  bool has_solution_hint() const;
  void clear_solution_hint();
  static const int kSolutionHintFieldNumber = 6;
  const ::operations_research::sat::PartialVariableAssignment& solution_hint() const;
  ::operations_research::sat::PartialVariableAssignment* release_solution_hint();
  ::operations_research::sat::PartialVariableAssignment* mutable_solution_hint();
  void set_allocated_solution_hint(::operations_research::sat::PartialVariableAssignment* solution_hint);

  // @@protoc_insertion_point(class_scope:operations_research.sat.CpModelProto)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto > variables_;
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::ConstraintProto > constraints_;
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto > search_strategy_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::operations_research::sat::CpObjectiveProto* objective_;
  ::operations_research::sat::PartialVariableAssignment* solution_hint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CpSolverResponse :
    public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CpSolverResponse) */ {
 public:
  CpSolverResponse();
  virtual ~CpSolverResponse();

  CpSolverResponse(const CpSolverResponse& from);

  inline CpSolverResponse& operator=(const CpSolverResponse& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  CpSolverResponse(CpSolverResponse&& from) noexcept
    : CpSolverResponse() {
    *this = ::std::move(from);
  }

  inline CpSolverResponse& operator=(CpSolverResponse&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor() {
    return default_instance().GetDescriptor();
  }
  static const CpSolverResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const CpSolverResponse* internal_default_instance() {
    return reinterpret_cast<const CpSolverResponse*>(
               &_CpSolverResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  void Swap(CpSolverResponse* other);
  friend void swap(CpSolverResponse& a, CpSolverResponse& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline CpSolverResponse* New() const final {
    return CreateMaybeMessage<CpSolverResponse>(nullptr);
  }

  CpSolverResponse* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<CpSolverResponse>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const CpSolverResponse& from);
  void MergeFrom(const CpSolverResponse& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  static const char* _InternalParse(const char* begin, const char* end, void* object, ::google::protobuf::internal::ParseContext* ctx);
  ::google::protobuf::internal::ParseFunc _ParseFunc() const final { return _InternalParse; }
  #else
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CpSolverResponse* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int64 solution = 2;
  int solution_size() const;
  void clear_solution();
  static const int kSolutionFieldNumber = 2;
  ::google::protobuf::int64 solution(int index) const;
  void set_solution(int index, ::google::protobuf::int64 value);
  void add_solution(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      solution() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_solution();

  // repeated int64 solution_lower_bounds = 18;
  int solution_lower_bounds_size() const;
  void clear_solution_lower_bounds();
  static const int kSolutionLowerBoundsFieldNumber = 18;
  ::google::protobuf::int64 solution_lower_bounds(int index) const;
  void set_solution_lower_bounds(int index, ::google::protobuf::int64 value);
  void add_solution_lower_bounds(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      solution_lower_bounds() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_solution_lower_bounds();

  // repeated int64 solution_upper_bounds = 19;
  int solution_upper_bounds_size() const;
  void clear_solution_upper_bounds();
  static const int kSolutionUpperBoundsFieldNumber = 19;
  ::google::protobuf::int64 solution_upper_bounds(int index) const;
  void set_solution_upper_bounds(int index, ::google::protobuf::int64 value);
  void add_solution_upper_bounds(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      solution_upper_bounds() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_solution_upper_bounds();

  // repeated .operations_research.sat.IntegerVariableProto tightened_variables = 21;
  int tightened_variables_size() const;
  void clear_tightened_variables();
  static const int kTightenedVariablesFieldNumber = 21;
  ::operations_research::sat::IntegerVariableProto* mutable_tightened_variables(int index);
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >*
      mutable_tightened_variables();
  const ::operations_research::sat::IntegerVariableProto& tightened_variables(int index) const;
  ::operations_research::sat::IntegerVariableProto* add_tightened_variables();
  const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >&
      tightened_variables() const;

  // string solution_info = 20;
  void clear_solution_info();
  static const int kSolutionInfoFieldNumber = 20;
  const ::std::string& solution_info() const;
  void set_solution_info(const ::std::string& value);
  #if LANG_CXX11
  void set_solution_info(::std::string&& value);
  #endif
  void set_solution_info(const char* value);
  void set_solution_info(const char* value, size_t size);
  ::std::string* mutable_solution_info();
  ::std::string* release_solution_info();
  void set_allocated_solution_info(::std::string* solution_info);

  // double objective_value = 3;
  void clear_objective_value();
  static const int kObjectiveValueFieldNumber = 3;
  double objective_value() const;
  void set_objective_value(double value);

  // .operations_research.sat.CpSolverStatus status = 1;
  void clear_status();
  static const int kStatusFieldNumber = 1;
  ::operations_research::sat::CpSolverStatus status() const;
  void set_status(::operations_research::sat::CpSolverStatus value);

  // bool all_solutions_were_found = 5;
  void clear_all_solutions_were_found();
  static const int kAllSolutionsWereFoundFieldNumber = 5;
  bool all_solutions_were_found() const;
  void set_all_solutions_were_found(bool value);

  // double best_objective_bound = 4;
  void clear_best_objective_bound();
  static const int kBestObjectiveBoundFieldNumber = 4;
  double best_objective_bound() const;
  void set_best_objective_bound(double value);

  // int64 num_booleans = 10;
  void clear_num_booleans();
  static const int kNumBooleansFieldNumber = 10;
  ::google::protobuf::int64 num_booleans() const;
  void set_num_booleans(::google::protobuf::int64 value);

  // int64 num_conflicts = 11;
  void clear_num_conflicts();
  static const int kNumConflictsFieldNumber = 11;
  ::google::protobuf::int64 num_conflicts() const;
  void set_num_conflicts(::google::protobuf::int64 value);

  // int64 num_branches = 12;
  void clear_num_branches();
  static const int kNumBranchesFieldNumber = 12;
  ::google::protobuf::int64 num_branches() const;
  void set_num_branches(::google::protobuf::int64 value);

  // int64 num_binary_propagations = 13;
  void clear_num_binary_propagations();
  static const int kNumBinaryPropagationsFieldNumber = 13;
  ::google::protobuf::int64 num_binary_propagations() const;
  void set_num_binary_propagations(::google::protobuf::int64 value);

  // int64 num_integer_propagations = 14;
  void clear_num_integer_propagations();
  static const int kNumIntegerPropagationsFieldNumber = 14;
  ::google::protobuf::int64 num_integer_propagations() const;
  void set_num_integer_propagations(::google::protobuf::int64 value);

  // double wall_time = 15;
  void clear_wall_time();
  static const int kWallTimeFieldNumber = 15;
  double wall_time() const;
  void set_wall_time(double value);

  // double user_time = 16;
  void clear_user_time();
  static const int kUserTimeFieldNumber = 16;
  double user_time() const;
  void set_user_time(double value);

  // double deterministic_time = 17;
  void clear_deterministic_time();
  static const int kDeterministicTimeFieldNumber = 17;
  double deterministic_time() const;
  void set_deterministic_time(double value);

  // @@protoc_insertion_point(class_scope:operations_research.sat.CpSolverResponse)
 private:
  class HasBitSetters;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > solution_;
  mutable std::atomic<int> _solution_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > solution_lower_bounds_;
  mutable std::atomic<int> _solution_lower_bounds_cached_byte_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > solution_upper_bounds_;
  mutable std::atomic<int> _solution_upper_bounds_cached_byte_size_;
  ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto > tightened_variables_;
  ::google::protobuf::internal::ArenaStringPtr solution_info_;
  double objective_value_;
  int status_;
  bool all_solutions_were_found_;
  double best_objective_bound_;
  ::google::protobuf::int64 num_booleans_;
  ::google::protobuf::int64 num_conflicts_;
  ::google::protobuf::int64 num_branches_;
  ::google::protobuf::int64 num_binary_propagations_;
  ::google::protobuf::int64 num_integer_propagations_;
  double wall_time_;
  double user_time_;
  double deterministic_time_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// IntegerVariableProto

// string name = 1;
inline void IntegerVariableProto::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& IntegerVariableProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntegerVariableProto.name)
  return name_.GetNoArena();
}
inline void IntegerVariableProto::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.sat.IntegerVariableProto.name)
}
#if LANG_CXX11
inline void IntegerVariableProto::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.sat.IntegerVariableProto.name)
}
#endif
inline void IntegerVariableProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.sat.IntegerVariableProto.name)
}
inline void IntegerVariableProto::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.IntegerVariableProto.name)
}
inline ::std::string* IntegerVariableProto::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:operations_research.sat.IntegerVariableProto.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* IntegerVariableProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.sat.IntegerVariableProto.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void IntegerVariableProto::set_allocated_name(::std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.IntegerVariableProto.name)
}

// repeated int64 domain = 2;
inline int IntegerVariableProto::domain_size() const {
  return domain_.size();
}
inline void IntegerVariableProto::clear_domain() {
  domain_.Clear();
}
inline ::google::protobuf::int64 IntegerVariableProto::domain(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntegerVariableProto.domain)
  return domain_.Get(index);
}
inline void IntegerVariableProto::set_domain(int index, ::google::protobuf::int64 value) {
  domain_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.IntegerVariableProto.domain)
}
inline void IntegerVariableProto::add_domain(::google::protobuf::int64 value) {
  domain_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.IntegerVariableProto.domain)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
IntegerVariableProto::domain() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.IntegerVariableProto.domain)
  return domain_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
IntegerVariableProto::mutable_domain() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.IntegerVariableProto.domain)
  return &domain_;
}

// -------------------------------------------------------------------

// BoolArgumentProto

// repeated int32 literals = 1;
inline int BoolArgumentProto::literals_size() const {
  return literals_.size();
}
inline void BoolArgumentProto::clear_literals() {
  literals_.Clear();
}
inline ::google::protobuf::int32 BoolArgumentProto::literals(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.BoolArgumentProto.literals)
  return literals_.Get(index);
}
inline void BoolArgumentProto::set_literals(int index, ::google::protobuf::int32 value) {
  literals_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.BoolArgumentProto.literals)
}
inline void BoolArgumentProto::add_literals(::google::protobuf::int32 value) {
  literals_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.BoolArgumentProto.literals)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
BoolArgumentProto::literals() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.BoolArgumentProto.literals)
  return literals_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
BoolArgumentProto::mutable_literals() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.BoolArgumentProto.literals)
  return &literals_;
}

// -------------------------------------------------------------------

// IntegerArgumentProto

// int32 target = 1;
inline void IntegerArgumentProto::clear_target() {
  target_ = 0;
}
inline ::google::protobuf::int32 IntegerArgumentProto::target() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntegerArgumentProto.target)
  return target_;
}
inline void IntegerArgumentProto::set_target(::google::protobuf::int32 value) {
  
  target_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.IntegerArgumentProto.target)
}

// repeated int32 vars = 2;
inline int IntegerArgumentProto::vars_size() const {
  return vars_.size();
}
inline void IntegerArgumentProto::clear_vars() {
  vars_.Clear();
}
inline ::google::protobuf::int32 IntegerArgumentProto::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntegerArgumentProto.vars)
  return vars_.Get(index);
}
inline void IntegerArgumentProto::set_vars(int index, ::google::protobuf::int32 value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.IntegerArgumentProto.vars)
}
inline void IntegerArgumentProto::add_vars(::google::protobuf::int32 value) {
  vars_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.IntegerArgumentProto.vars)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
IntegerArgumentProto::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.IntegerArgumentProto.vars)
  return vars_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
IntegerArgumentProto::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.IntegerArgumentProto.vars)
  return &vars_;
}

// -------------------------------------------------------------------

// AllDifferentConstraintProto

// repeated int32 vars = 1;
inline int AllDifferentConstraintProto::vars_size() const {
  return vars_.size();
}
inline void AllDifferentConstraintProto::clear_vars() {
  vars_.Clear();
}
inline ::google::protobuf::int32 AllDifferentConstraintProto::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.AllDifferentConstraintProto.vars)
  return vars_.Get(index);
}
inline void AllDifferentConstraintProto::set_vars(int index, ::google::protobuf::int32 value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.AllDifferentConstraintProto.vars)
}
inline void AllDifferentConstraintProto::add_vars(::google::protobuf::int32 value) {
  vars_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.AllDifferentConstraintProto.vars)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
AllDifferentConstraintProto::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.AllDifferentConstraintProto.vars)
  return vars_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
AllDifferentConstraintProto::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.AllDifferentConstraintProto.vars)
  return &vars_;
}

// -------------------------------------------------------------------

// LinearConstraintProto

// repeated int32 vars = 1;
inline int LinearConstraintProto::vars_size() const {
  return vars_.size();
}
inline void LinearConstraintProto::clear_vars() {
  vars_.Clear();
}
inline ::google::protobuf::int32 LinearConstraintProto::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.LinearConstraintProto.vars)
  return vars_.Get(index);
}
inline void LinearConstraintProto::set_vars(int index, ::google::protobuf::int32 value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.LinearConstraintProto.vars)
}
inline void LinearConstraintProto::add_vars(::google::protobuf::int32 value) {
  vars_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.LinearConstraintProto.vars)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
LinearConstraintProto::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.LinearConstraintProto.vars)
  return vars_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
LinearConstraintProto::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.LinearConstraintProto.vars)
  return &vars_;
}

// repeated int64 coeffs = 2;
inline int LinearConstraintProto::coeffs_size() const {
  return coeffs_.size();
}
inline void LinearConstraintProto::clear_coeffs() {
  coeffs_.Clear();
}
inline ::google::protobuf::int64 LinearConstraintProto::coeffs(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.LinearConstraintProto.coeffs)
  return coeffs_.Get(index);
}
inline void LinearConstraintProto::set_coeffs(int index, ::google::protobuf::int64 value) {
  coeffs_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.LinearConstraintProto.coeffs)
}
inline void LinearConstraintProto::add_coeffs(::google::protobuf::int64 value) {
  coeffs_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.LinearConstraintProto.coeffs)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
LinearConstraintProto::coeffs() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.LinearConstraintProto.coeffs)
  return coeffs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
LinearConstraintProto::mutable_coeffs() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.LinearConstraintProto.coeffs)
  return &coeffs_;
}

// repeated int64 domain = 3;
inline int LinearConstraintProto::domain_size() const {
  return domain_.size();
}
inline void LinearConstraintProto::clear_domain() {
  domain_.Clear();
}
inline ::google::protobuf::int64 LinearConstraintProto::domain(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.LinearConstraintProto.domain)
  return domain_.Get(index);
}
inline void LinearConstraintProto::set_domain(int index, ::google::protobuf::int64 value) {
  domain_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.LinearConstraintProto.domain)
}
inline void LinearConstraintProto::add_domain(::google::protobuf::int64 value) {
  domain_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.LinearConstraintProto.domain)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
LinearConstraintProto::domain() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.LinearConstraintProto.domain)
  return domain_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
LinearConstraintProto::mutable_domain() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.LinearConstraintProto.domain)
  return &domain_;
}

// -------------------------------------------------------------------

// ElementConstraintProto

// int32 index = 1;
inline void ElementConstraintProto::clear_index() {
  index_ = 0;
}
inline ::google::protobuf::int32 ElementConstraintProto::index() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ElementConstraintProto.index)
  return index_;
}
inline void ElementConstraintProto::set_index(::google::protobuf::int32 value) {
  
  index_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.ElementConstraintProto.index)
}

// int32 target = 2;
inline void ElementConstraintProto::clear_target() {
  target_ = 0;
}
inline ::google::protobuf::int32 ElementConstraintProto::target() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ElementConstraintProto.target)
  return target_;
}
inline void ElementConstraintProto::set_target(::google::protobuf::int32 value) {
  
  target_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.ElementConstraintProto.target)
}

// repeated int32 vars = 3;
inline int ElementConstraintProto::vars_size() const {
  return vars_.size();
}
inline void ElementConstraintProto::clear_vars() {
  vars_.Clear();
}
inline ::google::protobuf::int32 ElementConstraintProto::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ElementConstraintProto.vars)
  return vars_.Get(index);
}
inline void ElementConstraintProto::set_vars(int index, ::google::protobuf::int32 value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ElementConstraintProto.vars)
}
inline void ElementConstraintProto::add_vars(::google::protobuf::int32 value) {
  vars_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.ElementConstraintProto.vars)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ElementConstraintProto::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.ElementConstraintProto.vars)
  return vars_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ElementConstraintProto::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.ElementConstraintProto.vars)
  return &vars_;
}

// -------------------------------------------------------------------

// IntervalConstraintProto

// int32 start = 1;
inline void IntervalConstraintProto::clear_start() {
  start_ = 0;
}
inline ::google::protobuf::int32 IntervalConstraintProto::start() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntervalConstraintProto.start)
  return start_;
}
inline void IntervalConstraintProto::set_start(::google::protobuf::int32 value) {
  
  start_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.IntervalConstraintProto.start)
}

// int32 end = 2;
inline void IntervalConstraintProto::clear_end() {
  end_ = 0;
}
inline ::google::protobuf::int32 IntervalConstraintProto::end() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntervalConstraintProto.end)
  return end_;
}
inline void IntervalConstraintProto::set_end(::google::protobuf::int32 value) {
  
  end_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.IntervalConstraintProto.end)
}

// int32 size = 3;
inline void IntervalConstraintProto::clear_size() {
  size_ = 0;
}
inline ::google::protobuf::int32 IntervalConstraintProto::size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntervalConstraintProto.size)
  return size_;
}
inline void IntervalConstraintProto::set_size(::google::protobuf::int32 value) {
  
  size_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.IntervalConstraintProto.size)
}

// -------------------------------------------------------------------

// NoOverlapConstraintProto

// repeated int32 intervals = 1;
inline int NoOverlapConstraintProto::intervals_size() const {
  return intervals_.size();
}
inline void NoOverlapConstraintProto::clear_intervals() {
  intervals_.Clear();
}
inline ::google::protobuf::int32 NoOverlapConstraintProto::intervals(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.NoOverlapConstraintProto.intervals)
  return intervals_.Get(index);
}
inline void NoOverlapConstraintProto::set_intervals(int index, ::google::protobuf::int32 value) {
  intervals_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.NoOverlapConstraintProto.intervals)
}
inline void NoOverlapConstraintProto::add_intervals(::google::protobuf::int32 value) {
  intervals_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.NoOverlapConstraintProto.intervals)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
NoOverlapConstraintProto::intervals() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.NoOverlapConstraintProto.intervals)
  return intervals_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
NoOverlapConstraintProto::mutable_intervals() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.NoOverlapConstraintProto.intervals)
  return &intervals_;
}

// -------------------------------------------------------------------

// NoOverlap2DConstraintProto

// repeated int32 x_intervals = 1;
inline int NoOverlap2DConstraintProto::x_intervals_size() const {
  return x_intervals_.size();
}
inline void NoOverlap2DConstraintProto::clear_x_intervals() {
  x_intervals_.Clear();
}
inline ::google::protobuf::int32 NoOverlap2DConstraintProto::x_intervals(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.NoOverlap2DConstraintProto.x_intervals)
  return x_intervals_.Get(index);
}
inline void NoOverlap2DConstraintProto::set_x_intervals(int index, ::google::protobuf::int32 value) {
  x_intervals_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.NoOverlap2DConstraintProto.x_intervals)
}
inline void NoOverlap2DConstraintProto::add_x_intervals(::google::protobuf::int32 value) {
  x_intervals_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.NoOverlap2DConstraintProto.x_intervals)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
NoOverlap2DConstraintProto::x_intervals() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.NoOverlap2DConstraintProto.x_intervals)
  return x_intervals_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
NoOverlap2DConstraintProto::mutable_x_intervals() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.NoOverlap2DConstraintProto.x_intervals)
  return &x_intervals_;
}

// repeated int32 y_intervals = 2;
inline int NoOverlap2DConstraintProto::y_intervals_size() const {
  return y_intervals_.size();
}
inline void NoOverlap2DConstraintProto::clear_y_intervals() {
  y_intervals_.Clear();
}
inline ::google::protobuf::int32 NoOverlap2DConstraintProto::y_intervals(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.NoOverlap2DConstraintProto.y_intervals)
  return y_intervals_.Get(index);
}
inline void NoOverlap2DConstraintProto::set_y_intervals(int index, ::google::protobuf::int32 value) {
  y_intervals_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.NoOverlap2DConstraintProto.y_intervals)
}
inline void NoOverlap2DConstraintProto::add_y_intervals(::google::protobuf::int32 value) {
  y_intervals_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.NoOverlap2DConstraintProto.y_intervals)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
NoOverlap2DConstraintProto::y_intervals() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.NoOverlap2DConstraintProto.y_intervals)
  return y_intervals_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
NoOverlap2DConstraintProto::mutable_y_intervals() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.NoOverlap2DConstraintProto.y_intervals)
  return &y_intervals_;
}

// -------------------------------------------------------------------

// CumulativeConstraintProto

// int32 capacity = 1;
inline void CumulativeConstraintProto::clear_capacity() {
  capacity_ = 0;
}
inline ::google::protobuf::int32 CumulativeConstraintProto::capacity() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CumulativeConstraintProto.capacity)
  return capacity_;
}
inline void CumulativeConstraintProto::set_capacity(::google::protobuf::int32 value) {
  
  capacity_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CumulativeConstraintProto.capacity)
}

// repeated int32 intervals = 2;
inline int CumulativeConstraintProto::intervals_size() const {
  return intervals_.size();
}
inline void CumulativeConstraintProto::clear_intervals() {
  intervals_.Clear();
}
inline ::google::protobuf::int32 CumulativeConstraintProto::intervals(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CumulativeConstraintProto.intervals)
  return intervals_.Get(index);
}
inline void CumulativeConstraintProto::set_intervals(int index, ::google::protobuf::int32 value) {
  intervals_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CumulativeConstraintProto.intervals)
}
inline void CumulativeConstraintProto::add_intervals(::google::protobuf::int32 value) {
  intervals_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CumulativeConstraintProto.intervals)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
CumulativeConstraintProto::intervals() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CumulativeConstraintProto.intervals)
  return intervals_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
CumulativeConstraintProto::mutable_intervals() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CumulativeConstraintProto.intervals)
  return &intervals_;
}

// repeated int32 demands = 3;
inline int CumulativeConstraintProto::demands_size() const {
  return demands_.size();
}
inline void CumulativeConstraintProto::clear_demands() {
  demands_.Clear();
}
inline ::google::protobuf::int32 CumulativeConstraintProto::demands(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CumulativeConstraintProto.demands)
  return demands_.Get(index);
}
inline void CumulativeConstraintProto::set_demands(int index, ::google::protobuf::int32 value) {
  demands_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CumulativeConstraintProto.demands)
}
inline void CumulativeConstraintProto::add_demands(::google::protobuf::int32 value) {
  demands_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CumulativeConstraintProto.demands)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
CumulativeConstraintProto::demands() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CumulativeConstraintProto.demands)
  return demands_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
CumulativeConstraintProto::mutable_demands() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CumulativeConstraintProto.demands)
  return &demands_;
}

// -------------------------------------------------------------------

// ReservoirConstraintProto

// int64 min_level = 1;
inline void ReservoirConstraintProto::clear_min_level() {
  min_level_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 ReservoirConstraintProto::min_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.min_level)
  return min_level_;
}
inline void ReservoirConstraintProto::set_min_level(::google::protobuf::int64 value) {
  
  min_level_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.ReservoirConstraintProto.min_level)
}

// int64 max_level = 2;
inline void ReservoirConstraintProto::clear_max_level() {
  max_level_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 ReservoirConstraintProto::max_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.max_level)
  return max_level_;
}
inline void ReservoirConstraintProto::set_max_level(::google::protobuf::int64 value) {
  
  max_level_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.ReservoirConstraintProto.max_level)
}

// repeated int32 times = 3;
inline int ReservoirConstraintProto::times_size() const {
  return times_.size();
}
inline void ReservoirConstraintProto::clear_times() {
  times_.Clear();
}
inline ::google::protobuf::int32 ReservoirConstraintProto::times(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.times)
  return times_.Get(index);
}
inline void ReservoirConstraintProto::set_times(int index, ::google::protobuf::int32 value) {
  times_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ReservoirConstraintProto.times)
}
inline void ReservoirConstraintProto::add_times(::google::protobuf::int32 value) {
  times_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.ReservoirConstraintProto.times)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ReservoirConstraintProto::times() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.ReservoirConstraintProto.times)
  return times_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ReservoirConstraintProto::mutable_times() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.ReservoirConstraintProto.times)
  return &times_;
}

// repeated int64 demands = 4;
inline int ReservoirConstraintProto::demands_size() const {
  return demands_.size();
}
inline void ReservoirConstraintProto::clear_demands() {
  demands_.Clear();
}
inline ::google::protobuf::int64 ReservoirConstraintProto::demands(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.demands)
  return demands_.Get(index);
}
inline void ReservoirConstraintProto::set_demands(int index, ::google::protobuf::int64 value) {
  demands_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ReservoirConstraintProto.demands)
}
inline void ReservoirConstraintProto::add_demands(::google::protobuf::int64 value) {
  demands_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.ReservoirConstraintProto.demands)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
ReservoirConstraintProto::demands() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.ReservoirConstraintProto.demands)
  return demands_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
ReservoirConstraintProto::mutable_demands() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.ReservoirConstraintProto.demands)
  return &demands_;
}

// repeated int32 actives = 5;
inline int ReservoirConstraintProto::actives_size() const {
  return actives_.size();
}
inline void ReservoirConstraintProto::clear_actives() {
  actives_.Clear();
}
inline ::google::protobuf::int32 ReservoirConstraintProto::actives(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.actives)
  return actives_.Get(index);
}
inline void ReservoirConstraintProto::set_actives(int index, ::google::protobuf::int32 value) {
  actives_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ReservoirConstraintProto.actives)
}
inline void ReservoirConstraintProto::add_actives(::google::protobuf::int32 value) {
  actives_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.ReservoirConstraintProto.actives)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ReservoirConstraintProto::actives() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.ReservoirConstraintProto.actives)
  return actives_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ReservoirConstraintProto::mutable_actives() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.ReservoirConstraintProto.actives)
  return &actives_;
}

// -------------------------------------------------------------------

// CircuitConstraintProto

// repeated int32 tails = 3;
inline int CircuitConstraintProto::tails_size() const {
  return tails_.size();
}
inline void CircuitConstraintProto::clear_tails() {
  tails_.Clear();
}
inline ::google::protobuf::int32 CircuitConstraintProto::tails(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CircuitConstraintProto.tails)
  return tails_.Get(index);
}
inline void CircuitConstraintProto::set_tails(int index, ::google::protobuf::int32 value) {
  tails_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CircuitConstraintProto.tails)
}
inline void CircuitConstraintProto::add_tails(::google::protobuf::int32 value) {
  tails_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CircuitConstraintProto.tails)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
CircuitConstraintProto::tails() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CircuitConstraintProto.tails)
  return tails_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
CircuitConstraintProto::mutable_tails() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CircuitConstraintProto.tails)
  return &tails_;
}

// repeated int32 heads = 4;
inline int CircuitConstraintProto::heads_size() const {
  return heads_.size();
}
inline void CircuitConstraintProto::clear_heads() {
  heads_.Clear();
}
inline ::google::protobuf::int32 CircuitConstraintProto::heads(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CircuitConstraintProto.heads)
  return heads_.Get(index);
}
inline void CircuitConstraintProto::set_heads(int index, ::google::protobuf::int32 value) {
  heads_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CircuitConstraintProto.heads)
}
inline void CircuitConstraintProto::add_heads(::google::protobuf::int32 value) {
  heads_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CircuitConstraintProto.heads)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
CircuitConstraintProto::heads() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CircuitConstraintProto.heads)
  return heads_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
CircuitConstraintProto::mutable_heads() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CircuitConstraintProto.heads)
  return &heads_;
}

// repeated int32 literals = 5;
inline int CircuitConstraintProto::literals_size() const {
  return literals_.size();
}
inline void CircuitConstraintProto::clear_literals() {
  literals_.Clear();
}
inline ::google::protobuf::int32 CircuitConstraintProto::literals(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CircuitConstraintProto.literals)
  return literals_.Get(index);
}
inline void CircuitConstraintProto::set_literals(int index, ::google::protobuf::int32 value) {
  literals_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CircuitConstraintProto.literals)
}
inline void CircuitConstraintProto::add_literals(::google::protobuf::int32 value) {
  literals_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CircuitConstraintProto.literals)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
CircuitConstraintProto::literals() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CircuitConstraintProto.literals)
  return literals_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
CircuitConstraintProto::mutable_literals() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CircuitConstraintProto.literals)
  return &literals_;
}

// -------------------------------------------------------------------

// RoutesConstraintProto

// repeated int32 tails = 1;
inline int RoutesConstraintProto::tails_size() const {
  return tails_.size();
}
inline void RoutesConstraintProto::clear_tails() {
  tails_.Clear();
}
inline ::google::protobuf::int32 RoutesConstraintProto::tails(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.RoutesConstraintProto.tails)
  return tails_.Get(index);
}
inline void RoutesConstraintProto::set_tails(int index, ::google::protobuf::int32 value) {
  tails_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.RoutesConstraintProto.tails)
}
inline void RoutesConstraintProto::add_tails(::google::protobuf::int32 value) {
  tails_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.RoutesConstraintProto.tails)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
RoutesConstraintProto::tails() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.RoutesConstraintProto.tails)
  return tails_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
RoutesConstraintProto::mutable_tails() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.RoutesConstraintProto.tails)
  return &tails_;
}

// repeated int32 heads = 2;
inline int RoutesConstraintProto::heads_size() const {
  return heads_.size();
}
inline void RoutesConstraintProto::clear_heads() {
  heads_.Clear();
}
inline ::google::protobuf::int32 RoutesConstraintProto::heads(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.RoutesConstraintProto.heads)
  return heads_.Get(index);
}
inline void RoutesConstraintProto::set_heads(int index, ::google::protobuf::int32 value) {
  heads_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.RoutesConstraintProto.heads)
}
inline void RoutesConstraintProto::add_heads(::google::protobuf::int32 value) {
  heads_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.RoutesConstraintProto.heads)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
RoutesConstraintProto::heads() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.RoutesConstraintProto.heads)
  return heads_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
RoutesConstraintProto::mutable_heads() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.RoutesConstraintProto.heads)
  return &heads_;
}

// repeated int32 literals = 3;
inline int RoutesConstraintProto::literals_size() const {
  return literals_.size();
}
inline void RoutesConstraintProto::clear_literals() {
  literals_.Clear();
}
inline ::google::protobuf::int32 RoutesConstraintProto::literals(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.RoutesConstraintProto.literals)
  return literals_.Get(index);
}
inline void RoutesConstraintProto::set_literals(int index, ::google::protobuf::int32 value) {
  literals_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.RoutesConstraintProto.literals)
}
inline void RoutesConstraintProto::add_literals(::google::protobuf::int32 value) {
  literals_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.RoutesConstraintProto.literals)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
RoutesConstraintProto::literals() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.RoutesConstraintProto.literals)
  return literals_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
RoutesConstraintProto::mutable_literals() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.RoutesConstraintProto.literals)
  return &literals_;
}

// repeated int32 demands = 4;
inline int RoutesConstraintProto::demands_size() const {
  return demands_.size();
}
inline void RoutesConstraintProto::clear_demands() {
  demands_.Clear();
}
inline ::google::protobuf::int32 RoutesConstraintProto::demands(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.RoutesConstraintProto.demands)
  return demands_.Get(index);
}
inline void RoutesConstraintProto::set_demands(int index, ::google::protobuf::int32 value) {
  demands_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.RoutesConstraintProto.demands)
}
inline void RoutesConstraintProto::add_demands(::google::protobuf::int32 value) {
  demands_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.RoutesConstraintProto.demands)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
RoutesConstraintProto::demands() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.RoutesConstraintProto.demands)
  return demands_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
RoutesConstraintProto::mutable_demands() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.RoutesConstraintProto.demands)
  return &demands_;
}

// int64 capacity = 5;
inline void RoutesConstraintProto::clear_capacity() {
  capacity_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 RoutesConstraintProto::capacity() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.RoutesConstraintProto.capacity)
  return capacity_;
}
inline void RoutesConstraintProto::set_capacity(::google::protobuf::int64 value) {
  
  capacity_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.RoutesConstraintProto.capacity)
}

// -------------------------------------------------------------------

// CircuitCoveringConstraintProto

// repeated int32 nexts = 1;
inline int CircuitCoveringConstraintProto::nexts_size() const {
  return nexts_.size();
}
inline void CircuitCoveringConstraintProto::clear_nexts() {
  nexts_.Clear();
}
inline ::google::protobuf::int32 CircuitCoveringConstraintProto::nexts(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CircuitCoveringConstraintProto.nexts)
  return nexts_.Get(index);
}
inline void CircuitCoveringConstraintProto::set_nexts(int index, ::google::protobuf::int32 value) {
  nexts_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CircuitCoveringConstraintProto.nexts)
}
inline void CircuitCoveringConstraintProto::add_nexts(::google::protobuf::int32 value) {
  nexts_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CircuitCoveringConstraintProto.nexts)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
CircuitCoveringConstraintProto::nexts() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CircuitCoveringConstraintProto.nexts)
  return nexts_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
CircuitCoveringConstraintProto::mutable_nexts() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CircuitCoveringConstraintProto.nexts)
  return &nexts_;
}

// repeated int64 distinguished_nodes = 2;
inline int CircuitCoveringConstraintProto::distinguished_nodes_size() const {
  return distinguished_nodes_.size();
}
inline void CircuitCoveringConstraintProto::clear_distinguished_nodes() {
  distinguished_nodes_.Clear();
}
inline ::google::protobuf::int64 CircuitCoveringConstraintProto::distinguished_nodes(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CircuitCoveringConstraintProto.distinguished_nodes)
  return distinguished_nodes_.Get(index);
}
inline void CircuitCoveringConstraintProto::set_distinguished_nodes(int index, ::google::protobuf::int64 value) {
  distinguished_nodes_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CircuitCoveringConstraintProto.distinguished_nodes)
}
inline void CircuitCoveringConstraintProto::add_distinguished_nodes(::google::protobuf::int64 value) {
  distinguished_nodes_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CircuitCoveringConstraintProto.distinguished_nodes)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
CircuitCoveringConstraintProto::distinguished_nodes() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CircuitCoveringConstraintProto.distinguished_nodes)
  return distinguished_nodes_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
CircuitCoveringConstraintProto::mutable_distinguished_nodes() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CircuitCoveringConstraintProto.distinguished_nodes)
  return &distinguished_nodes_;
}

// -------------------------------------------------------------------

// TableConstraintProto

// repeated int32 vars = 1;
inline int TableConstraintProto::vars_size() const {
  return vars_.size();
}
inline void TableConstraintProto::clear_vars() {
  vars_.Clear();
}
inline ::google::protobuf::int32 TableConstraintProto::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.TableConstraintProto.vars)
  return vars_.Get(index);
}
inline void TableConstraintProto::set_vars(int index, ::google::protobuf::int32 value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.TableConstraintProto.vars)
}
inline void TableConstraintProto::add_vars(::google::protobuf::int32 value) {
  vars_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.TableConstraintProto.vars)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TableConstraintProto::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.TableConstraintProto.vars)
  return vars_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TableConstraintProto::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.TableConstraintProto.vars)
  return &vars_;
}

// repeated int64 values = 2;
inline int TableConstraintProto::values_size() const {
  return values_.size();
}
inline void TableConstraintProto::clear_values() {
  values_.Clear();
}
inline ::google::protobuf::int64 TableConstraintProto::values(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.TableConstraintProto.values)
  return values_.Get(index);
}
inline void TableConstraintProto::set_values(int index, ::google::protobuf::int64 value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.TableConstraintProto.values)
}
inline void TableConstraintProto::add_values(::google::protobuf::int64 value) {
  values_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.TableConstraintProto.values)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TableConstraintProto::values() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.TableConstraintProto.values)
  return values_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TableConstraintProto::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.TableConstraintProto.values)
  return &values_;
}

// bool negated = 3;
inline void TableConstraintProto::clear_negated() {
  negated_ = false;
}
inline bool TableConstraintProto::negated() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.TableConstraintProto.negated)
  return negated_;
}
inline void TableConstraintProto::set_negated(bool value) {
  
  negated_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.TableConstraintProto.negated)
}

// -------------------------------------------------------------------

// InverseConstraintProto

// repeated int32 f_direct = 1;
inline int InverseConstraintProto::f_direct_size() const {
  return f_direct_.size();
}
inline void InverseConstraintProto::clear_f_direct() {
  f_direct_.Clear();
}
inline ::google::protobuf::int32 InverseConstraintProto::f_direct(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.InverseConstraintProto.f_direct)
  return f_direct_.Get(index);
}
inline void InverseConstraintProto::set_f_direct(int index, ::google::protobuf::int32 value) {
  f_direct_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.InverseConstraintProto.f_direct)
}
inline void InverseConstraintProto::add_f_direct(::google::protobuf::int32 value) {
  f_direct_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.InverseConstraintProto.f_direct)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
InverseConstraintProto::f_direct() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.InverseConstraintProto.f_direct)
  return f_direct_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
InverseConstraintProto::mutable_f_direct() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.InverseConstraintProto.f_direct)
  return &f_direct_;
}

// repeated int32 f_inverse = 2;
inline int InverseConstraintProto::f_inverse_size() const {
  return f_inverse_.size();
}
inline void InverseConstraintProto::clear_f_inverse() {
  f_inverse_.Clear();
}
inline ::google::protobuf::int32 InverseConstraintProto::f_inverse(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.InverseConstraintProto.f_inverse)
  return f_inverse_.Get(index);
}
inline void InverseConstraintProto::set_f_inverse(int index, ::google::protobuf::int32 value) {
  f_inverse_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.InverseConstraintProto.f_inverse)
}
inline void InverseConstraintProto::add_f_inverse(::google::protobuf::int32 value) {
  f_inverse_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.InverseConstraintProto.f_inverse)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
InverseConstraintProto::f_inverse() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.InverseConstraintProto.f_inverse)
  return f_inverse_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
InverseConstraintProto::mutable_f_inverse() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.InverseConstraintProto.f_inverse)
  return &f_inverse_;
}

// -------------------------------------------------------------------

// AutomatonConstraintProto

// int64 starting_state = 2;
inline void AutomatonConstraintProto::clear_starting_state() {
  starting_state_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 AutomatonConstraintProto::starting_state() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.AutomatonConstraintProto.starting_state)
  return starting_state_;
}
inline void AutomatonConstraintProto::set_starting_state(::google::protobuf::int64 value) {
  
  starting_state_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.AutomatonConstraintProto.starting_state)
}

// repeated int64 final_states = 3;
inline int AutomatonConstraintProto::final_states_size() const {
  return final_states_.size();
}
inline void AutomatonConstraintProto::clear_final_states() {
  final_states_.Clear();
}
inline ::google::protobuf::int64 AutomatonConstraintProto::final_states(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.AutomatonConstraintProto.final_states)
  return final_states_.Get(index);
}
inline void AutomatonConstraintProto::set_final_states(int index, ::google::protobuf::int64 value) {
  final_states_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.AutomatonConstraintProto.final_states)
}
inline void AutomatonConstraintProto::add_final_states(::google::protobuf::int64 value) {
  final_states_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.AutomatonConstraintProto.final_states)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
AutomatonConstraintProto::final_states() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.AutomatonConstraintProto.final_states)
  return final_states_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
AutomatonConstraintProto::mutable_final_states() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.AutomatonConstraintProto.final_states)
  return &final_states_;
}

// repeated int64 transition_tail = 4;
inline int AutomatonConstraintProto::transition_tail_size() const {
  return transition_tail_.size();
}
inline void AutomatonConstraintProto::clear_transition_tail() {
  transition_tail_.Clear();
}
inline ::google::protobuf::int64 AutomatonConstraintProto::transition_tail(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.AutomatonConstraintProto.transition_tail)
  return transition_tail_.Get(index);
}
inline void AutomatonConstraintProto::set_transition_tail(int index, ::google::protobuf::int64 value) {
  transition_tail_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.AutomatonConstraintProto.transition_tail)
}
inline void AutomatonConstraintProto::add_transition_tail(::google::protobuf::int64 value) {
  transition_tail_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.AutomatonConstraintProto.transition_tail)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
AutomatonConstraintProto::transition_tail() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.AutomatonConstraintProto.transition_tail)
  return transition_tail_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
AutomatonConstraintProto::mutable_transition_tail() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.AutomatonConstraintProto.transition_tail)
  return &transition_tail_;
}

// repeated int64 transition_head = 5;
inline int AutomatonConstraintProto::transition_head_size() const {
  return transition_head_.size();
}
inline void AutomatonConstraintProto::clear_transition_head() {
  transition_head_.Clear();
}
inline ::google::protobuf::int64 AutomatonConstraintProto::transition_head(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.AutomatonConstraintProto.transition_head)
  return transition_head_.Get(index);
}
inline void AutomatonConstraintProto::set_transition_head(int index, ::google::protobuf::int64 value) {
  transition_head_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.AutomatonConstraintProto.transition_head)
}
inline void AutomatonConstraintProto::add_transition_head(::google::protobuf::int64 value) {
  transition_head_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.AutomatonConstraintProto.transition_head)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
AutomatonConstraintProto::transition_head() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.AutomatonConstraintProto.transition_head)
  return transition_head_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
AutomatonConstraintProto::mutable_transition_head() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.AutomatonConstraintProto.transition_head)
  return &transition_head_;
}

// repeated int64 transition_label = 6;
inline int AutomatonConstraintProto::transition_label_size() const {
  return transition_label_.size();
}
inline void AutomatonConstraintProto::clear_transition_label() {
  transition_label_.Clear();
}
inline ::google::protobuf::int64 AutomatonConstraintProto::transition_label(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.AutomatonConstraintProto.transition_label)
  return transition_label_.Get(index);
}
inline void AutomatonConstraintProto::set_transition_label(int index, ::google::protobuf::int64 value) {
  transition_label_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.AutomatonConstraintProto.transition_label)
}
inline void AutomatonConstraintProto::add_transition_label(::google::protobuf::int64 value) {
  transition_label_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.AutomatonConstraintProto.transition_label)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
AutomatonConstraintProto::transition_label() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.AutomatonConstraintProto.transition_label)
  return transition_label_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
AutomatonConstraintProto::mutable_transition_label() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.AutomatonConstraintProto.transition_label)
  return &transition_label_;
}

// repeated int32 vars = 7;
inline int AutomatonConstraintProto::vars_size() const {
  return vars_.size();
}
inline void AutomatonConstraintProto::clear_vars() {
  vars_.Clear();
}
inline ::google::protobuf::int32 AutomatonConstraintProto::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.AutomatonConstraintProto.vars)
  return vars_.Get(index);
}
inline void AutomatonConstraintProto::set_vars(int index, ::google::protobuf::int32 value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.AutomatonConstraintProto.vars)
}
inline void AutomatonConstraintProto::add_vars(::google::protobuf::int32 value) {
  vars_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.AutomatonConstraintProto.vars)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
AutomatonConstraintProto::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.AutomatonConstraintProto.vars)
  return vars_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
AutomatonConstraintProto::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.AutomatonConstraintProto.vars)
  return &vars_;
}

// -------------------------------------------------------------------

// ConstraintProto

// string name = 1;
inline void ConstraintProto::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ConstraintProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.name)
  return name_.GetNoArena();
}
inline void ConstraintProto::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ConstraintProto.name)
}
#if LANG_CXX11
inline void ConstraintProto::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.sat.ConstraintProto.name)
}
#endif
inline void ConstraintProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.sat.ConstraintProto.name)
}
inline void ConstraintProto::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.ConstraintProto.name)
}
inline ::std::string* ConstraintProto::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ConstraintProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ConstraintProto::set_allocated_name(::std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.ConstraintProto.name)
}

// repeated int32 enforcement_literal = 2;
inline int ConstraintProto::enforcement_literal_size() const {
  return enforcement_literal_.size();
}
inline void ConstraintProto::clear_enforcement_literal() {
  enforcement_literal_.Clear();
}
inline ::google::protobuf::int32 ConstraintProto::enforcement_literal(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.enforcement_literal)
  return enforcement_literal_.Get(index);
}
inline void ConstraintProto::set_enforcement_literal(int index, ::google::protobuf::int32 value) {
  enforcement_literal_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ConstraintProto.enforcement_literal)
}
inline void ConstraintProto::add_enforcement_literal(::google::protobuf::int32 value) {
  enforcement_literal_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.ConstraintProto.enforcement_literal)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ConstraintProto::enforcement_literal() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.ConstraintProto.enforcement_literal)
  return enforcement_literal_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ConstraintProto::mutable_enforcement_literal() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.ConstraintProto.enforcement_literal)
  return &enforcement_literal_;
}

// .operations_research.sat.BoolArgumentProto bool_or = 3;
inline bool ConstraintProto::has_bool_or() const {
  return constraint_case() == kBoolOr;
}
inline void ConstraintProto::set_has_bool_or() {
  _oneof_case_[0] = kBoolOr;
}
inline void ConstraintProto::clear_bool_or() {
  if (has_bool_or()) {
    delete constraint_.bool_or_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::release_bool_or() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.bool_or)
  if (has_bool_or()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_or_;
    constraint_.bool_or_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::bool_or() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.bool_or)
  return has_bool_or()
      ? *constraint_.bool_or_
      : *reinterpret_cast< ::operations_research::sat::BoolArgumentProto*>(&::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_bool_or() {
  if (!has_bool_or()) {
    clear_constraint();
    set_has_bool_or();
    constraint_.bool_or_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.bool_or)
  return constraint_.bool_or_;
}

// .operations_research.sat.BoolArgumentProto bool_and = 4;
inline bool ConstraintProto::has_bool_and() const {
  return constraint_case() == kBoolAnd;
}
inline void ConstraintProto::set_has_bool_and() {
  _oneof_case_[0] = kBoolAnd;
}
inline void ConstraintProto::clear_bool_and() {
  if (has_bool_and()) {
    delete constraint_.bool_and_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::release_bool_and() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.bool_and)
  if (has_bool_and()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_and_;
    constraint_.bool_and_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::bool_and() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.bool_and)
  return has_bool_and()
      ? *constraint_.bool_and_
      : *reinterpret_cast< ::operations_research::sat::BoolArgumentProto*>(&::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_bool_and() {
  if (!has_bool_and()) {
    clear_constraint();
    set_has_bool_and();
    constraint_.bool_and_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.bool_and)
  return constraint_.bool_and_;
}

// .operations_research.sat.BoolArgumentProto at_most_one = 26;
inline bool ConstraintProto::has_at_most_one() const {
  return constraint_case() == kAtMostOne;
}
inline void ConstraintProto::set_has_at_most_one() {
  _oneof_case_[0] = kAtMostOne;
}
inline void ConstraintProto::clear_at_most_one() {
  if (has_at_most_one()) {
    delete constraint_.at_most_one_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::release_at_most_one() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.at_most_one)
  if (has_at_most_one()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.at_most_one_;
    constraint_.at_most_one_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::at_most_one() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.at_most_one)
  return has_at_most_one()
      ? *constraint_.at_most_one_
      : *reinterpret_cast< ::operations_research::sat::BoolArgumentProto*>(&::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_at_most_one() {
  if (!has_at_most_one()) {
    clear_constraint();
    set_has_at_most_one();
    constraint_.at_most_one_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.at_most_one)
  return constraint_.at_most_one_;
}

// .operations_research.sat.BoolArgumentProto bool_xor = 5;
inline bool ConstraintProto::has_bool_xor() const {
  return constraint_case() == kBoolXor;
}
inline void ConstraintProto::set_has_bool_xor() {
  _oneof_case_[0] = kBoolXor;
}
inline void ConstraintProto::clear_bool_xor() {
  if (has_bool_xor()) {
    delete constraint_.bool_xor_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::release_bool_xor() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.bool_xor)
  if (has_bool_xor()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_xor_;
    constraint_.bool_xor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::bool_xor() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.bool_xor)
  return has_bool_xor()
      ? *constraint_.bool_xor_
      : *reinterpret_cast< ::operations_research::sat::BoolArgumentProto*>(&::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_bool_xor() {
  if (!has_bool_xor()) {
    clear_constraint();
    set_has_bool_xor();
    constraint_.bool_xor_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.bool_xor)
  return constraint_.bool_xor_;
}

// .operations_research.sat.IntegerArgumentProto int_div = 7;
inline bool ConstraintProto::has_int_div() const {
  return constraint_case() == kIntDiv;
}
inline void ConstraintProto::set_has_int_div() {
  _oneof_case_[0] = kIntDiv;
}
inline void ConstraintProto::clear_int_div() {
  if (has_int_div()) {
    delete constraint_.int_div_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::release_int_div() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.int_div)
  if (has_int_div()) {
    clear_has_constraint();
      ::operations_research::sat::IntegerArgumentProto* temp = constraint_.int_div_;
    constraint_.int_div_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::IntegerArgumentProto& ConstraintProto::int_div() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.int_div)
  return has_int_div()
      ? *constraint_.int_div_
      : *reinterpret_cast< ::operations_research::sat::IntegerArgumentProto*>(&::operations_research::sat::_IntegerArgumentProto_default_instance_);
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::mutable_int_div() {
  if (!has_int_div()) {
    clear_constraint();
    set_has_int_div();
    constraint_.int_div_ = CreateMaybeMessage< ::operations_research::sat::IntegerArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.int_div)
  return constraint_.int_div_;
}

// .operations_research.sat.IntegerArgumentProto int_mod = 8;
inline bool ConstraintProto::has_int_mod() const {
  return constraint_case() == kIntMod;
}
inline void ConstraintProto::set_has_int_mod() {
  _oneof_case_[0] = kIntMod;
}
inline void ConstraintProto::clear_int_mod() {
  if (has_int_mod()) {
    delete constraint_.int_mod_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::release_int_mod() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.int_mod)
  if (has_int_mod()) {
    clear_has_constraint();
      ::operations_research::sat::IntegerArgumentProto* temp = constraint_.int_mod_;
    constraint_.int_mod_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::IntegerArgumentProto& ConstraintProto::int_mod() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.int_mod)
  return has_int_mod()
      ? *constraint_.int_mod_
      : *reinterpret_cast< ::operations_research::sat::IntegerArgumentProto*>(&::operations_research::sat::_IntegerArgumentProto_default_instance_);
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::mutable_int_mod() {
  if (!has_int_mod()) {
    clear_constraint();
    set_has_int_mod();
    constraint_.int_mod_ = CreateMaybeMessage< ::operations_research::sat::IntegerArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.int_mod)
  return constraint_.int_mod_;
}

// .operations_research.sat.IntegerArgumentProto int_max = 9;
inline bool ConstraintProto::has_int_max() const {
  return constraint_case() == kIntMax;
}
inline void ConstraintProto::set_has_int_max() {
  _oneof_case_[0] = kIntMax;
}
inline void ConstraintProto::clear_int_max() {
  if (has_int_max()) {
    delete constraint_.int_max_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::release_int_max() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.int_max)
  if (has_int_max()) {
    clear_has_constraint();
      ::operations_research::sat::IntegerArgumentProto* temp = constraint_.int_max_;
    constraint_.int_max_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::IntegerArgumentProto& ConstraintProto::int_max() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.int_max)
  return has_int_max()
      ? *constraint_.int_max_
      : *reinterpret_cast< ::operations_research::sat::IntegerArgumentProto*>(&::operations_research::sat::_IntegerArgumentProto_default_instance_);
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::mutable_int_max() {
  if (!has_int_max()) {
    clear_constraint();
    set_has_int_max();
    constraint_.int_max_ = CreateMaybeMessage< ::operations_research::sat::IntegerArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.int_max)
  return constraint_.int_max_;
}

// .operations_research.sat.IntegerArgumentProto int_min = 10;
inline bool ConstraintProto::has_int_min() const {
  return constraint_case() == kIntMin;
}
inline void ConstraintProto::set_has_int_min() {
  _oneof_case_[0] = kIntMin;
}
inline void ConstraintProto::clear_int_min() {
  if (has_int_min()) {
    delete constraint_.int_min_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::release_int_min() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.int_min)
  if (has_int_min()) {
    clear_has_constraint();
      ::operations_research::sat::IntegerArgumentProto* temp = constraint_.int_min_;
    constraint_.int_min_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::IntegerArgumentProto& ConstraintProto::int_min() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.int_min)
  return has_int_min()
      ? *constraint_.int_min_
      : *reinterpret_cast< ::operations_research::sat::IntegerArgumentProto*>(&::operations_research::sat::_IntegerArgumentProto_default_instance_);
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::mutable_int_min() {
  if (!has_int_min()) {
    clear_constraint();
    set_has_int_min();
    constraint_.int_min_ = CreateMaybeMessage< ::operations_research::sat::IntegerArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.int_min)
  return constraint_.int_min_;
}

// .operations_research.sat.IntegerArgumentProto int_prod = 11;
inline bool ConstraintProto::has_int_prod() const {
  return constraint_case() == kIntProd;
}
inline void ConstraintProto::set_has_int_prod() {
  _oneof_case_[0] = kIntProd;
}
inline void ConstraintProto::clear_int_prod() {
  if (has_int_prod()) {
    delete constraint_.int_prod_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::release_int_prod() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.int_prod)
  if (has_int_prod()) {
    clear_has_constraint();
      ::operations_research::sat::IntegerArgumentProto* temp = constraint_.int_prod_;
    constraint_.int_prod_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::IntegerArgumentProto& ConstraintProto::int_prod() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.int_prod)
  return has_int_prod()
      ? *constraint_.int_prod_
      : *reinterpret_cast< ::operations_research::sat::IntegerArgumentProto*>(&::operations_research::sat::_IntegerArgumentProto_default_instance_);
}
inline ::operations_research::sat::IntegerArgumentProto* ConstraintProto::mutable_int_prod() {
  if (!has_int_prod()) {
    clear_constraint();
    set_has_int_prod();
    constraint_.int_prod_ = CreateMaybeMessage< ::operations_research::sat::IntegerArgumentProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.int_prod)
  return constraint_.int_prod_;
}

// .operations_research.sat.LinearConstraintProto linear = 12;
inline bool ConstraintProto::has_linear() const {
  return constraint_case() == kLinear;
}
inline void ConstraintProto::set_has_linear() {
  _oneof_case_[0] = kLinear;
}
inline void ConstraintProto::clear_linear() {
  if (has_linear()) {
    delete constraint_.linear_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::LinearConstraintProto* ConstraintProto::release_linear() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.linear)
  if (has_linear()) {
    clear_has_constraint();
      ::operations_research::sat::LinearConstraintProto* temp = constraint_.linear_;
    constraint_.linear_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::LinearConstraintProto& ConstraintProto::linear() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.linear)
  return has_linear()
      ? *constraint_.linear_
      : *reinterpret_cast< ::operations_research::sat::LinearConstraintProto*>(&::operations_research::sat::_LinearConstraintProto_default_instance_);
}
inline ::operations_research::sat::LinearConstraintProto* ConstraintProto::mutable_linear() {
  if (!has_linear()) {
    clear_constraint();
    set_has_linear();
    constraint_.linear_ = CreateMaybeMessage< ::operations_research::sat::LinearConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.linear)
  return constraint_.linear_;
}

// .operations_research.sat.AllDifferentConstraintProto all_diff = 13;
inline bool ConstraintProto::has_all_diff() const {
  return constraint_case() == kAllDiff;
}
inline void ConstraintProto::set_has_all_diff() {
  _oneof_case_[0] = kAllDiff;
}
inline void ConstraintProto::clear_all_diff() {
  if (has_all_diff()) {
    delete constraint_.all_diff_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::AllDifferentConstraintProto* ConstraintProto::release_all_diff() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.all_diff)
  if (has_all_diff()) {
    clear_has_constraint();
      ::operations_research::sat::AllDifferentConstraintProto* temp = constraint_.all_diff_;
    constraint_.all_diff_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::AllDifferentConstraintProto& ConstraintProto::all_diff() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.all_diff)
  return has_all_diff()
      ? *constraint_.all_diff_
      : *reinterpret_cast< ::operations_research::sat::AllDifferentConstraintProto*>(&::operations_research::sat::_AllDifferentConstraintProto_default_instance_);
}
inline ::operations_research::sat::AllDifferentConstraintProto* ConstraintProto::mutable_all_diff() {
  if (!has_all_diff()) {
    clear_constraint();
    set_has_all_diff();
    constraint_.all_diff_ = CreateMaybeMessage< ::operations_research::sat::AllDifferentConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.all_diff)
  return constraint_.all_diff_;
}

// .operations_research.sat.ElementConstraintProto element = 14;
inline bool ConstraintProto::has_element() const {
  return constraint_case() == kElement;
}
inline void ConstraintProto::set_has_element() {
  _oneof_case_[0] = kElement;
}
inline void ConstraintProto::clear_element() {
  if (has_element()) {
    delete constraint_.element_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::ElementConstraintProto* ConstraintProto::release_element() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.element)
  if (has_element()) {
    clear_has_constraint();
      ::operations_research::sat::ElementConstraintProto* temp = constraint_.element_;
    constraint_.element_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::ElementConstraintProto& ConstraintProto::element() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.element)
  return has_element()
      ? *constraint_.element_
      : *reinterpret_cast< ::operations_research::sat::ElementConstraintProto*>(&::operations_research::sat::_ElementConstraintProto_default_instance_);
}
inline ::operations_research::sat::ElementConstraintProto* ConstraintProto::mutable_element() {
  if (!has_element()) {
    clear_constraint();
    set_has_element();
    constraint_.element_ = CreateMaybeMessage< ::operations_research::sat::ElementConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.element)
  return constraint_.element_;
}

// .operations_research.sat.CircuitConstraintProto circuit = 15;
inline bool ConstraintProto::has_circuit() const {
  return constraint_case() == kCircuit;
}
inline void ConstraintProto::set_has_circuit() {
  _oneof_case_[0] = kCircuit;
}
inline void ConstraintProto::clear_circuit() {
  if (has_circuit()) {
    delete constraint_.circuit_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::CircuitConstraintProto* ConstraintProto::release_circuit() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.circuit)
  if (has_circuit()) {
    clear_has_constraint();
      ::operations_research::sat::CircuitConstraintProto* temp = constraint_.circuit_;
    constraint_.circuit_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::CircuitConstraintProto& ConstraintProto::circuit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.circuit)
  return has_circuit()
      ? *constraint_.circuit_
      : *reinterpret_cast< ::operations_research::sat::CircuitConstraintProto*>(&::operations_research::sat::_CircuitConstraintProto_default_instance_);
}
inline ::operations_research::sat::CircuitConstraintProto* ConstraintProto::mutable_circuit() {
  if (!has_circuit()) {
    clear_constraint();
    set_has_circuit();
    constraint_.circuit_ = CreateMaybeMessage< ::operations_research::sat::CircuitConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.circuit)
  return constraint_.circuit_;
}

// .operations_research.sat.RoutesConstraintProto routes = 23;
inline bool ConstraintProto::has_routes() const {
  return constraint_case() == kRoutes;
}
inline void ConstraintProto::set_has_routes() {
  _oneof_case_[0] = kRoutes;
}
inline void ConstraintProto::clear_routes() {
  if (has_routes()) {
    delete constraint_.routes_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::RoutesConstraintProto* ConstraintProto::release_routes() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.routes)
  if (has_routes()) {
    clear_has_constraint();
      ::operations_research::sat::RoutesConstraintProto* temp = constraint_.routes_;
    constraint_.routes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::RoutesConstraintProto& ConstraintProto::routes() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.routes)
  return has_routes()
      ? *constraint_.routes_
      : *reinterpret_cast< ::operations_research::sat::RoutesConstraintProto*>(&::operations_research::sat::_RoutesConstraintProto_default_instance_);
}
inline ::operations_research::sat::RoutesConstraintProto* ConstraintProto::mutable_routes() {
  if (!has_routes()) {
    clear_constraint();
    set_has_routes();
    constraint_.routes_ = CreateMaybeMessage< ::operations_research::sat::RoutesConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.routes)
  return constraint_.routes_;
}

// .operations_research.sat.CircuitCoveringConstraintProto circuit_covering = 25;
inline bool ConstraintProto::has_circuit_covering() const {
  return constraint_case() == kCircuitCovering;
}
inline void ConstraintProto::set_has_circuit_covering() {
  _oneof_case_[0] = kCircuitCovering;
}
inline void ConstraintProto::clear_circuit_covering() {
  if (has_circuit_covering()) {
    delete constraint_.circuit_covering_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::CircuitCoveringConstraintProto* ConstraintProto::release_circuit_covering() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.circuit_covering)
  if (has_circuit_covering()) {
    clear_has_constraint();
      ::operations_research::sat::CircuitCoveringConstraintProto* temp = constraint_.circuit_covering_;
    constraint_.circuit_covering_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::CircuitCoveringConstraintProto& ConstraintProto::circuit_covering() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.circuit_covering)
  return has_circuit_covering()
      ? *constraint_.circuit_covering_
      : *reinterpret_cast< ::operations_research::sat::CircuitCoveringConstraintProto*>(&::operations_research::sat::_CircuitCoveringConstraintProto_default_instance_);
}
inline ::operations_research::sat::CircuitCoveringConstraintProto* ConstraintProto::mutable_circuit_covering() {
  if (!has_circuit_covering()) {
    clear_constraint();
    set_has_circuit_covering();
    constraint_.circuit_covering_ = CreateMaybeMessage< ::operations_research::sat::CircuitCoveringConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.circuit_covering)
  return constraint_.circuit_covering_;
}

// .operations_research.sat.TableConstraintProto table = 16;
inline bool ConstraintProto::has_table() const {
  return constraint_case() == kTable;
}
inline void ConstraintProto::set_has_table() {
  _oneof_case_[0] = kTable;
}
inline void ConstraintProto::clear_table() {
  if (has_table()) {
    delete constraint_.table_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::TableConstraintProto* ConstraintProto::release_table() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.table)
  if (has_table()) {
    clear_has_constraint();
      ::operations_research::sat::TableConstraintProto* temp = constraint_.table_;
    constraint_.table_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::TableConstraintProto& ConstraintProto::table() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.table)
  return has_table()
      ? *constraint_.table_
      : *reinterpret_cast< ::operations_research::sat::TableConstraintProto*>(&::operations_research::sat::_TableConstraintProto_default_instance_);
}
inline ::operations_research::sat::TableConstraintProto* ConstraintProto::mutable_table() {
  if (!has_table()) {
    clear_constraint();
    set_has_table();
    constraint_.table_ = CreateMaybeMessage< ::operations_research::sat::TableConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.table)
  return constraint_.table_;
}

// .operations_research.sat.AutomatonConstraintProto automaton = 17;
inline bool ConstraintProto::has_automaton() const {
  return constraint_case() == kAutomaton;
}
inline void ConstraintProto::set_has_automaton() {
  _oneof_case_[0] = kAutomaton;
}
inline void ConstraintProto::clear_automaton() {
  if (has_automaton()) {
    delete constraint_.automaton_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::AutomatonConstraintProto* ConstraintProto::release_automaton() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.automaton)
  if (has_automaton()) {
    clear_has_constraint();
      ::operations_research::sat::AutomatonConstraintProto* temp = constraint_.automaton_;
    constraint_.automaton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::AutomatonConstraintProto& ConstraintProto::automaton() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.automaton)
  return has_automaton()
      ? *constraint_.automaton_
      : *reinterpret_cast< ::operations_research::sat::AutomatonConstraintProto*>(&::operations_research::sat::_AutomatonConstraintProto_default_instance_);
}
inline ::operations_research::sat::AutomatonConstraintProto* ConstraintProto::mutable_automaton() {
  if (!has_automaton()) {
    clear_constraint();
    set_has_automaton();
    constraint_.automaton_ = CreateMaybeMessage< ::operations_research::sat::AutomatonConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.automaton)
  return constraint_.automaton_;
}

// .operations_research.sat.InverseConstraintProto inverse = 18;
inline bool ConstraintProto::has_inverse() const {
  return constraint_case() == kInverse;
}
inline void ConstraintProto::set_has_inverse() {
  _oneof_case_[0] = kInverse;
}
inline void ConstraintProto::clear_inverse() {
  if (has_inverse()) {
    delete constraint_.inverse_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::InverseConstraintProto* ConstraintProto::release_inverse() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.inverse)
  if (has_inverse()) {
    clear_has_constraint();
      ::operations_research::sat::InverseConstraintProto* temp = constraint_.inverse_;
    constraint_.inverse_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::InverseConstraintProto& ConstraintProto::inverse() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.inverse)
  return has_inverse()
      ? *constraint_.inverse_
      : *reinterpret_cast< ::operations_research::sat::InverseConstraintProto*>(&::operations_research::sat::_InverseConstraintProto_default_instance_);
}
inline ::operations_research::sat::InverseConstraintProto* ConstraintProto::mutable_inverse() {
  if (!has_inverse()) {
    clear_constraint();
    set_has_inverse();
    constraint_.inverse_ = CreateMaybeMessage< ::operations_research::sat::InverseConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.inverse)
  return constraint_.inverse_;
}

// .operations_research.sat.ReservoirConstraintProto reservoir = 24;
inline bool ConstraintProto::has_reservoir() const {
  return constraint_case() == kReservoir;
}
inline void ConstraintProto::set_has_reservoir() {
  _oneof_case_[0] = kReservoir;
}
inline void ConstraintProto::clear_reservoir() {
  if (has_reservoir()) {
    delete constraint_.reservoir_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::ReservoirConstraintProto* ConstraintProto::release_reservoir() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.reservoir)
  if (has_reservoir()) {
    clear_has_constraint();
      ::operations_research::sat::ReservoirConstraintProto* temp = constraint_.reservoir_;
    constraint_.reservoir_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::ReservoirConstraintProto& ConstraintProto::reservoir() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.reservoir)
  return has_reservoir()
      ? *constraint_.reservoir_
      : *reinterpret_cast< ::operations_research::sat::ReservoirConstraintProto*>(&::operations_research::sat::_ReservoirConstraintProto_default_instance_);
}
inline ::operations_research::sat::ReservoirConstraintProto* ConstraintProto::mutable_reservoir() {
  if (!has_reservoir()) {
    clear_constraint();
    set_has_reservoir();
    constraint_.reservoir_ = CreateMaybeMessage< ::operations_research::sat::ReservoirConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.reservoir)
  return constraint_.reservoir_;
}

// .operations_research.sat.IntervalConstraintProto interval = 19;
inline bool ConstraintProto::has_interval() const {
  return constraint_case() == kInterval;
}
inline void ConstraintProto::set_has_interval() {
  _oneof_case_[0] = kInterval;
}
inline void ConstraintProto::clear_interval() {
  if (has_interval()) {
    delete constraint_.interval_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::IntervalConstraintProto* ConstraintProto::release_interval() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.interval)
  if (has_interval()) {
    clear_has_constraint();
      ::operations_research::sat::IntervalConstraintProto* temp = constraint_.interval_;
    constraint_.interval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::IntervalConstraintProto& ConstraintProto::interval() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.interval)
  return has_interval()
      ? *constraint_.interval_
      : *reinterpret_cast< ::operations_research::sat::IntervalConstraintProto*>(&::operations_research::sat::_IntervalConstraintProto_default_instance_);
}
inline ::operations_research::sat::IntervalConstraintProto* ConstraintProto::mutable_interval() {
  if (!has_interval()) {
    clear_constraint();
    set_has_interval();
    constraint_.interval_ = CreateMaybeMessage< ::operations_research::sat::IntervalConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.interval)
  return constraint_.interval_;
}

// .operations_research.sat.NoOverlapConstraintProto no_overlap = 20;
inline bool ConstraintProto::has_no_overlap() const {
  return constraint_case() == kNoOverlap;
}
inline void ConstraintProto::set_has_no_overlap() {
  _oneof_case_[0] = kNoOverlap;
}
inline void ConstraintProto::clear_no_overlap() {
  if (has_no_overlap()) {
    delete constraint_.no_overlap_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::NoOverlapConstraintProto* ConstraintProto::release_no_overlap() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.no_overlap)
  if (has_no_overlap()) {
    clear_has_constraint();
      ::operations_research::sat::NoOverlapConstraintProto* temp = constraint_.no_overlap_;
    constraint_.no_overlap_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::NoOverlapConstraintProto& ConstraintProto::no_overlap() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.no_overlap)
  return has_no_overlap()
      ? *constraint_.no_overlap_
      : *reinterpret_cast< ::operations_research::sat::NoOverlapConstraintProto*>(&::operations_research::sat::_NoOverlapConstraintProto_default_instance_);
}
inline ::operations_research::sat::NoOverlapConstraintProto* ConstraintProto::mutable_no_overlap() {
  if (!has_no_overlap()) {
    clear_constraint();
    set_has_no_overlap();
    constraint_.no_overlap_ = CreateMaybeMessage< ::operations_research::sat::NoOverlapConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.no_overlap)
  return constraint_.no_overlap_;
}

// .operations_research.sat.NoOverlap2DConstraintProto no_overlap_2d = 21;
inline bool ConstraintProto::has_no_overlap_2d() const {
  return constraint_case() == kNoOverlap2D;
}
inline void ConstraintProto::set_has_no_overlap_2d() {
  _oneof_case_[0] = kNoOverlap2D;
}
inline void ConstraintProto::clear_no_overlap_2d() {
  if (has_no_overlap_2d()) {
    delete constraint_.no_overlap_2d_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::NoOverlap2DConstraintProto* ConstraintProto::release_no_overlap_2d() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.no_overlap_2d)
  if (has_no_overlap_2d()) {
    clear_has_constraint();
      ::operations_research::sat::NoOverlap2DConstraintProto* temp = constraint_.no_overlap_2d_;
    constraint_.no_overlap_2d_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::NoOverlap2DConstraintProto& ConstraintProto::no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.no_overlap_2d)
  return has_no_overlap_2d()
      ? *constraint_.no_overlap_2d_
      : *reinterpret_cast< ::operations_research::sat::NoOverlap2DConstraintProto*>(&::operations_research::sat::_NoOverlap2DConstraintProto_default_instance_);
}
inline ::operations_research::sat::NoOverlap2DConstraintProto* ConstraintProto::mutable_no_overlap_2d() {
  if (!has_no_overlap_2d()) {
    clear_constraint();
    set_has_no_overlap_2d();
    constraint_.no_overlap_2d_ = CreateMaybeMessage< ::operations_research::sat::NoOverlap2DConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.no_overlap_2d)
  return constraint_.no_overlap_2d_;
}

// .operations_research.sat.CumulativeConstraintProto cumulative = 22;
inline bool ConstraintProto::has_cumulative() const {
  return constraint_case() == kCumulative;
}
inline void ConstraintProto::set_has_cumulative() {
  _oneof_case_[0] = kCumulative;
}
inline void ConstraintProto::clear_cumulative() {
  if (has_cumulative()) {
    delete constraint_.cumulative_;
    clear_has_constraint();
  }
}
inline ::operations_research::sat::CumulativeConstraintProto* ConstraintProto::release_cumulative() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.cumulative)
  if (has_cumulative()) {
    clear_has_constraint();
      ::operations_research::sat::CumulativeConstraintProto* temp = constraint_.cumulative_;
    constraint_.cumulative_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::CumulativeConstraintProto& ConstraintProto::cumulative() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.cumulative)
  return has_cumulative()
      ? *constraint_.cumulative_
      : *reinterpret_cast< ::operations_research::sat::CumulativeConstraintProto*>(&::operations_research::sat::_CumulativeConstraintProto_default_instance_);
}
inline ::operations_research::sat::CumulativeConstraintProto* ConstraintProto::mutable_cumulative() {
  if (!has_cumulative()) {
    clear_constraint();
    set_has_cumulative();
    constraint_.cumulative_ = CreateMaybeMessage< ::operations_research::sat::CumulativeConstraintProto >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.cumulative)
  return constraint_.cumulative_;
}

inline bool ConstraintProto::has_constraint() const {
  return constraint_case() != CONSTRAINT_NOT_SET;
}
inline void ConstraintProto::clear_has_constraint() {
  _oneof_case_[0] = CONSTRAINT_NOT_SET;
}
inline ConstraintProto::ConstraintCase ConstraintProto::constraint_case() const {
  return ConstraintProto::ConstraintCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// CpObjectiveProto

// repeated int32 vars = 1;
inline int CpObjectiveProto::vars_size() const {
  return vars_.size();
}
inline void CpObjectiveProto::clear_vars() {
  vars_.Clear();
}
inline ::google::protobuf::int32 CpObjectiveProto::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.vars)
  return vars_.Get(index);
}
inline void CpObjectiveProto::set_vars(int index, ::google::protobuf::int32 value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.vars)
}
inline void CpObjectiveProto::add_vars(::google::protobuf::int32 value) {
  vars_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpObjectiveProto.vars)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
CpObjectiveProto::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpObjectiveProto.vars)
  return vars_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
CpObjectiveProto::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpObjectiveProto.vars)
  return &vars_;
}

// repeated int64 coeffs = 4;
inline int CpObjectiveProto::coeffs_size() const {
  return coeffs_.size();
}
inline void CpObjectiveProto::clear_coeffs() {
  coeffs_.Clear();
}
inline ::google::protobuf::int64 CpObjectiveProto::coeffs(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.coeffs)
  return coeffs_.Get(index);
}
inline void CpObjectiveProto::set_coeffs(int index, ::google::protobuf::int64 value) {
  coeffs_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.coeffs)
}
inline void CpObjectiveProto::add_coeffs(::google::protobuf::int64 value) {
  coeffs_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpObjectiveProto.coeffs)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
CpObjectiveProto::coeffs() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpObjectiveProto.coeffs)
  return coeffs_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
CpObjectiveProto::mutable_coeffs() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpObjectiveProto.coeffs)
  return &coeffs_;
}

// double offset = 2;
inline void CpObjectiveProto::clear_offset() {
  offset_ = 0;
}
inline double CpObjectiveProto::offset() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.offset)
  return offset_;
}
inline void CpObjectiveProto::set_offset(double value) {
  
  offset_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.offset)
}

// double scaling_factor = 3;
inline void CpObjectiveProto::clear_scaling_factor() {
  scaling_factor_ = 0;
}
inline double CpObjectiveProto::scaling_factor() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.scaling_factor)
  return scaling_factor_;
}
inline void CpObjectiveProto::set_scaling_factor(double value) {
  
  scaling_factor_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.scaling_factor)
}

// repeated int64 domain = 5;
inline int CpObjectiveProto::domain_size() const {
  return domain_.size();
}
inline void CpObjectiveProto::clear_domain() {
  domain_.Clear();
}
inline ::google::protobuf::int64 CpObjectiveProto::domain(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.domain)
  return domain_.Get(index);
}
inline void CpObjectiveProto::set_domain(int index, ::google::protobuf::int64 value) {
  domain_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.domain)
}
inline void CpObjectiveProto::add_domain(::google::protobuf::int64 value) {
  domain_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpObjectiveProto.domain)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
CpObjectiveProto::domain() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpObjectiveProto.domain)
  return domain_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
CpObjectiveProto::mutable_domain() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpObjectiveProto.domain)
  return &domain_;
}

// -------------------------------------------------------------------

// DecisionStrategyProto_AffineTransformation

// int32 var = 1;
inline void DecisionStrategyProto_AffineTransformation::clear_var() {
  var_ = 0;
}
inline ::google::protobuf::int32 DecisionStrategyProto_AffineTransformation::var() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.AffineTransformation.var)
  return var_;
}
inline void DecisionStrategyProto_AffineTransformation::set_var(::google::protobuf::int32 value) {
  
  var_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.AffineTransformation.var)
}

// int64 offset = 2;
inline void DecisionStrategyProto_AffineTransformation::clear_offset() {
  offset_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 DecisionStrategyProto_AffineTransformation::offset() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.AffineTransformation.offset)
  return offset_;
}
inline void DecisionStrategyProto_AffineTransformation::set_offset(::google::protobuf::int64 value) {
  
  offset_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.AffineTransformation.offset)
}

// int64 positive_coeff = 3;
inline void DecisionStrategyProto_AffineTransformation::clear_positive_coeff() {
  positive_coeff_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 DecisionStrategyProto_AffineTransformation::positive_coeff() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.AffineTransformation.positive_coeff)
  return positive_coeff_;
}
inline void DecisionStrategyProto_AffineTransformation::set_positive_coeff(::google::protobuf::int64 value) {
  
  positive_coeff_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.AffineTransformation.positive_coeff)
}

// -------------------------------------------------------------------

// DecisionStrategyProto

// repeated int32 variables = 1;
inline int DecisionStrategyProto::variables_size() const {
  return variables_.size();
}
inline void DecisionStrategyProto::clear_variables() {
  variables_.Clear();
}
inline ::google::protobuf::int32 DecisionStrategyProto::variables(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.variables)
  return variables_.Get(index);
}
inline void DecisionStrategyProto::set_variables(int index, ::google::protobuf::int32 value) {
  variables_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.variables)
}
inline void DecisionStrategyProto::add_variables(::google::protobuf::int32 value) {
  variables_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.DecisionStrategyProto.variables)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
DecisionStrategyProto::variables() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.DecisionStrategyProto.variables)
  return variables_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
DecisionStrategyProto::mutable_variables() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.DecisionStrategyProto.variables)
  return &variables_;
}

// .operations_research.sat.DecisionStrategyProto.VariableSelectionStrategy variable_selection_strategy = 2;
inline void DecisionStrategyProto::clear_variable_selection_strategy() {
  variable_selection_strategy_ = 0;
}
inline ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy DecisionStrategyProto::variable_selection_strategy() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.variable_selection_strategy)
  return static_cast< ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy >(variable_selection_strategy_);
}
inline void DecisionStrategyProto::set_variable_selection_strategy(::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy value) {
  
  variable_selection_strategy_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.variable_selection_strategy)
}

// .operations_research.sat.DecisionStrategyProto.DomainReductionStrategy domain_reduction_strategy = 3;
inline void DecisionStrategyProto::clear_domain_reduction_strategy() {
  domain_reduction_strategy_ = 0;
}
inline ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy DecisionStrategyProto::domain_reduction_strategy() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.domain_reduction_strategy)
  return static_cast< ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy >(domain_reduction_strategy_);
}
inline void DecisionStrategyProto::set_domain_reduction_strategy(::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy value) {
  
  domain_reduction_strategy_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.domain_reduction_strategy)
}

// repeated .operations_research.sat.DecisionStrategyProto.AffineTransformation transformations = 4;
inline int DecisionStrategyProto::transformations_size() const {
  return transformations_.size();
}
inline void DecisionStrategyProto::clear_transformations() {
  transformations_.Clear();
}
inline ::operations_research::sat::DecisionStrategyProto_AffineTransformation* DecisionStrategyProto::mutable_transformations(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.DecisionStrategyProto.transformations)
  return transformations_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto_AffineTransformation >*
DecisionStrategyProto::mutable_transformations() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.DecisionStrategyProto.transformations)
  return &transformations_;
}
inline const ::operations_research::sat::DecisionStrategyProto_AffineTransformation& DecisionStrategyProto::transformations(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.transformations)
  return transformations_.Get(index);
}
inline ::operations_research::sat::DecisionStrategyProto_AffineTransformation* DecisionStrategyProto::add_transformations() {
  // @@protoc_insertion_point(field_add:operations_research.sat.DecisionStrategyProto.transformations)
  return transformations_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto_AffineTransformation >&
DecisionStrategyProto::transformations() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.DecisionStrategyProto.transformations)
  return transformations_;
}

// -------------------------------------------------------------------

// PartialVariableAssignment

// repeated int32 vars = 1;
inline int PartialVariableAssignment::vars_size() const {
  return vars_.size();
}
inline void PartialVariableAssignment::clear_vars() {
  vars_.Clear();
}
inline ::google::protobuf::int32 PartialVariableAssignment::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.PartialVariableAssignment.vars)
  return vars_.Get(index);
}
inline void PartialVariableAssignment::set_vars(int index, ::google::protobuf::int32 value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.PartialVariableAssignment.vars)
}
inline void PartialVariableAssignment::add_vars(::google::protobuf::int32 value) {
  vars_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.PartialVariableAssignment.vars)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
PartialVariableAssignment::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.PartialVariableAssignment.vars)
  return vars_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
PartialVariableAssignment::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.PartialVariableAssignment.vars)
  return &vars_;
}

// repeated int64 values = 2;
inline int PartialVariableAssignment::values_size() const {
  return values_.size();
}
inline void PartialVariableAssignment::clear_values() {
  values_.Clear();
}
inline ::google::protobuf::int64 PartialVariableAssignment::values(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.PartialVariableAssignment.values)
  return values_.Get(index);
}
inline void PartialVariableAssignment::set_values(int index, ::google::protobuf::int64 value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.PartialVariableAssignment.values)
}
inline void PartialVariableAssignment::add_values(::google::protobuf::int64 value) {
  values_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.PartialVariableAssignment.values)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
PartialVariableAssignment::values() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.PartialVariableAssignment.values)
  return values_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
PartialVariableAssignment::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.PartialVariableAssignment.values)
  return &values_;
}

// -------------------------------------------------------------------

// CpModelProto

// string name = 1;
inline void CpModelProto::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& CpModelProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.name)
  return name_.GetNoArena();
}
inline void CpModelProto::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpModelProto.name)
}
#if LANG_CXX11
inline void CpModelProto::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.sat.CpModelProto.name)
}
#endif
inline void CpModelProto::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.sat.CpModelProto.name)
}
inline void CpModelProto::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.CpModelProto.name)
}
inline ::std::string* CpModelProto::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CpModelProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpModelProto.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CpModelProto::set_allocated_name(::std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpModelProto.name)
}

// repeated .operations_research.sat.IntegerVariableProto variables = 2;
inline int CpModelProto::variables_size() const {
  return variables_.size();
}
inline void CpModelProto::clear_variables() {
  variables_.Clear();
}
inline ::operations_research::sat::IntegerVariableProto* CpModelProto::mutable_variables(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.variables)
  return variables_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >*
CpModelProto::mutable_variables() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpModelProto.variables)
  return &variables_;
}
inline const ::operations_research::sat::IntegerVariableProto& CpModelProto::variables(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.variables)
  return variables_.Get(index);
}
inline ::operations_research::sat::IntegerVariableProto* CpModelProto::add_variables() {
  // @@protoc_insertion_point(field_add:operations_research.sat.CpModelProto.variables)
  return variables_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >&
CpModelProto::variables() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpModelProto.variables)
  return variables_;
}

// repeated .operations_research.sat.ConstraintProto constraints = 3;
inline int CpModelProto::constraints_size() const {
  return constraints_.size();
}
inline void CpModelProto::clear_constraints() {
  constraints_.Clear();
}
inline ::operations_research::sat::ConstraintProto* CpModelProto::mutable_constraints(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.constraints)
  return constraints_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::operations_research::sat::ConstraintProto >*
CpModelProto::mutable_constraints() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpModelProto.constraints)
  return &constraints_;
}
inline const ::operations_research::sat::ConstraintProto& CpModelProto::constraints(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.constraints)
  return constraints_.Get(index);
}
inline ::operations_research::sat::ConstraintProto* CpModelProto::add_constraints() {
  // @@protoc_insertion_point(field_add:operations_research.sat.CpModelProto.constraints)
  return constraints_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::ConstraintProto >&
CpModelProto::constraints() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpModelProto.constraints)
  return constraints_;
}

// .operations_research.sat.CpObjectiveProto objective = 4;
inline bool CpModelProto::has_objective() const {
  return this != internal_default_instance() && objective_ != nullptr;
}
inline void CpModelProto::clear_objective() {
  if (GetArenaNoVirtual() == nullptr && objective_ != nullptr) {
    delete objective_;
  }
  objective_ = nullptr;
}
inline const ::operations_research::sat::CpObjectiveProto& CpModelProto::objective() const {
  const ::operations_research::sat::CpObjectiveProto* p = objective_;
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.objective)
  return p != nullptr ? *p : *reinterpret_cast<const ::operations_research::sat::CpObjectiveProto*>(
      &::operations_research::sat::_CpObjectiveProto_default_instance_);
}
inline ::operations_research::sat::CpObjectiveProto* CpModelProto::release_objective() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpModelProto.objective)
  
  ::operations_research::sat::CpObjectiveProto* temp = objective_;
  objective_ = nullptr;
  return temp;
}
inline ::operations_research::sat::CpObjectiveProto* CpModelProto::mutable_objective() {
  
  if (objective_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::CpObjectiveProto>(GetArenaNoVirtual());
    objective_ = p;
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.objective)
  return objective_;
}
inline void CpModelProto::set_allocated_objective(::operations_research::sat::CpObjectiveProto* objective) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete objective_;
  }
  if (objective) {
    ::google::protobuf::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      objective = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, objective, submessage_arena);
    }
    
  } else {
    
  }
  objective_ = objective;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpModelProto.objective)
}

// repeated .operations_research.sat.DecisionStrategyProto search_strategy = 5;
inline int CpModelProto::search_strategy_size() const {
  return search_strategy_.size();
}
inline void CpModelProto::clear_search_strategy() {
  search_strategy_.Clear();
}
inline ::operations_research::sat::DecisionStrategyProto* CpModelProto::mutable_search_strategy(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.search_strategy)
  return search_strategy_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto >*
CpModelProto::mutable_search_strategy() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpModelProto.search_strategy)
  return &search_strategy_;
}
inline const ::operations_research::sat::DecisionStrategyProto& CpModelProto::search_strategy(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.search_strategy)
  return search_strategy_.Get(index);
}
inline ::operations_research::sat::DecisionStrategyProto* CpModelProto::add_search_strategy() {
  // @@protoc_insertion_point(field_add:operations_research.sat.CpModelProto.search_strategy)
  return search_strategy_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto >&
CpModelProto::search_strategy() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpModelProto.search_strategy)
  return search_strategy_;
}

// .operations_research.sat.PartialVariableAssignment solution_hint = 6;
inline bool CpModelProto::has_solution_hint() const {
  return this != internal_default_instance() && solution_hint_ != nullptr;
}
inline void CpModelProto::clear_solution_hint() {
  if (GetArenaNoVirtual() == nullptr && solution_hint_ != nullptr) {
    delete solution_hint_;
  }
  solution_hint_ = nullptr;
}
inline const ::operations_research::sat::PartialVariableAssignment& CpModelProto::solution_hint() const {
  const ::operations_research::sat::PartialVariableAssignment* p = solution_hint_;
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.solution_hint)
  return p != nullptr ? *p : *reinterpret_cast<const ::operations_research::sat::PartialVariableAssignment*>(
      &::operations_research::sat::_PartialVariableAssignment_default_instance_);
}
inline ::operations_research::sat::PartialVariableAssignment* CpModelProto::release_solution_hint() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpModelProto.solution_hint)
  
  ::operations_research::sat::PartialVariableAssignment* temp = solution_hint_;
  solution_hint_ = nullptr;
  return temp;
}
inline ::operations_research::sat::PartialVariableAssignment* CpModelProto::mutable_solution_hint() {
  
  if (solution_hint_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::PartialVariableAssignment>(GetArenaNoVirtual());
    solution_hint_ = p;
  }
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.solution_hint)
  return solution_hint_;
}
inline void CpModelProto::set_allocated_solution_hint(::operations_research::sat::PartialVariableAssignment* solution_hint) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete solution_hint_;
  }
  if (solution_hint) {
    ::google::protobuf::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      solution_hint = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, solution_hint, submessage_arena);
    }
    
  } else {
    
  }
  solution_hint_ = solution_hint;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpModelProto.solution_hint)
}

// -------------------------------------------------------------------

// CpSolverResponse

// .operations_research.sat.CpSolverStatus status = 1;
inline void CpSolverResponse::clear_status() {
  status_ = 0;
}
inline ::operations_research::sat::CpSolverStatus CpSolverResponse::status() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.status)
  return static_cast< ::operations_research::sat::CpSolverStatus >(status_);
}
inline void CpSolverResponse::set_status(::operations_research::sat::CpSolverStatus value) {
  
  status_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.status)
}

// repeated int64 solution = 2;
inline int CpSolverResponse::solution_size() const {
  return solution_.size();
}
inline void CpSolverResponse::clear_solution() {
  solution_.Clear();
}
inline ::google::protobuf::int64 CpSolverResponse::solution(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.solution)
  return solution_.Get(index);
}
inline void CpSolverResponse::set_solution(int index, ::google::protobuf::int64 value) {
  solution_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.solution)
}
inline void CpSolverResponse::add_solution(::google::protobuf::int64 value) {
  solution_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpSolverResponse.solution)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
CpSolverResponse::solution() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpSolverResponse.solution)
  return solution_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
CpSolverResponse::mutable_solution() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpSolverResponse.solution)
  return &solution_;
}

// double objective_value = 3;
inline void CpSolverResponse::clear_objective_value() {
  objective_value_ = 0;
}
inline double CpSolverResponse::objective_value() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.objective_value)
  return objective_value_;
}
inline void CpSolverResponse::set_objective_value(double value) {
  
  objective_value_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.objective_value)
}

// double best_objective_bound = 4;
inline void CpSolverResponse::clear_best_objective_bound() {
  best_objective_bound_ = 0;
}
inline double CpSolverResponse::best_objective_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.best_objective_bound)
  return best_objective_bound_;
}
inline void CpSolverResponse::set_best_objective_bound(double value) {
  
  best_objective_bound_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.best_objective_bound)
}

// repeated int64 solution_lower_bounds = 18;
inline int CpSolverResponse::solution_lower_bounds_size() const {
  return solution_lower_bounds_.size();
}
inline void CpSolverResponse::clear_solution_lower_bounds() {
  solution_lower_bounds_.Clear();
}
inline ::google::protobuf::int64 CpSolverResponse::solution_lower_bounds(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.solution_lower_bounds)
  return solution_lower_bounds_.Get(index);
}
inline void CpSolverResponse::set_solution_lower_bounds(int index, ::google::protobuf::int64 value) {
  solution_lower_bounds_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.solution_lower_bounds)
}
inline void CpSolverResponse::add_solution_lower_bounds(::google::protobuf::int64 value) {
  solution_lower_bounds_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpSolverResponse.solution_lower_bounds)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
CpSolverResponse::solution_lower_bounds() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpSolverResponse.solution_lower_bounds)
  return solution_lower_bounds_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
CpSolverResponse::mutable_solution_lower_bounds() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpSolverResponse.solution_lower_bounds)
  return &solution_lower_bounds_;
}

// repeated int64 solution_upper_bounds = 19;
inline int CpSolverResponse::solution_upper_bounds_size() const {
  return solution_upper_bounds_.size();
}
inline void CpSolverResponse::clear_solution_upper_bounds() {
  solution_upper_bounds_.Clear();
}
inline ::google::protobuf::int64 CpSolverResponse::solution_upper_bounds(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.solution_upper_bounds)
  return solution_upper_bounds_.Get(index);
}
inline void CpSolverResponse::set_solution_upper_bounds(int index, ::google::protobuf::int64 value) {
  solution_upper_bounds_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.solution_upper_bounds)
}
inline void CpSolverResponse::add_solution_upper_bounds(::google::protobuf::int64 value) {
  solution_upper_bounds_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpSolverResponse.solution_upper_bounds)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
CpSolverResponse::solution_upper_bounds() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpSolverResponse.solution_upper_bounds)
  return solution_upper_bounds_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
CpSolverResponse::mutable_solution_upper_bounds() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpSolverResponse.solution_upper_bounds)
  return &solution_upper_bounds_;
}

// repeated .operations_research.sat.IntegerVariableProto tightened_variables = 21;
inline int CpSolverResponse::tightened_variables_size() const {
  return tightened_variables_.size();
}
inline void CpSolverResponse::clear_tightened_variables() {
  tightened_variables_.Clear();
}
inline ::operations_research::sat::IntegerVariableProto* CpSolverResponse::mutable_tightened_variables(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpSolverResponse.tightened_variables)
  return tightened_variables_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >*
CpSolverResponse::mutable_tightened_variables() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpSolverResponse.tightened_variables)
  return &tightened_variables_;
}
inline const ::operations_research::sat::IntegerVariableProto& CpSolverResponse::tightened_variables(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.tightened_variables)
  return tightened_variables_.Get(index);
}
inline ::operations_research::sat::IntegerVariableProto* CpSolverResponse::add_tightened_variables() {
  // @@protoc_insertion_point(field_add:operations_research.sat.CpSolverResponse.tightened_variables)
  return tightened_variables_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >&
CpSolverResponse::tightened_variables() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpSolverResponse.tightened_variables)
  return tightened_variables_;
}

// bool all_solutions_were_found = 5;
inline void CpSolverResponse::clear_all_solutions_were_found() {
  all_solutions_were_found_ = false;
}
inline bool CpSolverResponse::all_solutions_were_found() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.all_solutions_were_found)
  return all_solutions_were_found_;
}
inline void CpSolverResponse::set_all_solutions_were_found(bool value) {
  
  all_solutions_were_found_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.all_solutions_were_found)
}

// int64 num_booleans = 10;
inline void CpSolverResponse::clear_num_booleans() {
  num_booleans_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 CpSolverResponse::num_booleans() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_booleans)
  return num_booleans_;
}
inline void CpSolverResponse::set_num_booleans(::google::protobuf::int64 value) {
  
  num_booleans_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.num_booleans)
}

// int64 num_conflicts = 11;
inline void CpSolverResponse::clear_num_conflicts() {
  num_conflicts_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 CpSolverResponse::num_conflicts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_conflicts)
  return num_conflicts_;
}
inline void CpSolverResponse::set_num_conflicts(::google::protobuf::int64 value) {
  
  num_conflicts_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.num_conflicts)
}

// int64 num_branches = 12;
inline void CpSolverResponse::clear_num_branches() {
  num_branches_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 CpSolverResponse::num_branches() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_branches)
  return num_branches_;
}
inline void CpSolverResponse::set_num_branches(::google::protobuf::int64 value) {
  
  num_branches_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.num_branches)
}

// int64 num_binary_propagations = 13;
inline void CpSolverResponse::clear_num_binary_propagations() {
  num_binary_propagations_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 CpSolverResponse::num_binary_propagations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_binary_propagations)
  return num_binary_propagations_;
}
inline void CpSolverResponse::set_num_binary_propagations(::google::protobuf::int64 value) {
  
  num_binary_propagations_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.num_binary_propagations)
}

// int64 num_integer_propagations = 14;
inline void CpSolverResponse::clear_num_integer_propagations() {
  num_integer_propagations_ = PROTOBUF_LONGLONG(0);
}
inline ::google::protobuf::int64 CpSolverResponse::num_integer_propagations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_integer_propagations)
  return num_integer_propagations_;
}
inline void CpSolverResponse::set_num_integer_propagations(::google::protobuf::int64 value) {
  
  num_integer_propagations_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.num_integer_propagations)
}

// double wall_time = 15;
inline void CpSolverResponse::clear_wall_time() {
  wall_time_ = 0;
}
inline double CpSolverResponse::wall_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.wall_time)
  return wall_time_;
}
inline void CpSolverResponse::set_wall_time(double value) {
  
  wall_time_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.wall_time)
}

// double user_time = 16;
inline void CpSolverResponse::clear_user_time() {
  user_time_ = 0;
}
inline double CpSolverResponse::user_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.user_time)
  return user_time_;
}
inline void CpSolverResponse::set_user_time(double value) {
  
  user_time_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.user_time)
}

// double deterministic_time = 17;
inline void CpSolverResponse::clear_deterministic_time() {
  deterministic_time_ = 0;
}
inline double CpSolverResponse::deterministic_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.deterministic_time)
  return deterministic_time_;
}
inline void CpSolverResponse::set_deterministic_time(double value) {
  
  deterministic_time_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.deterministic_time)
}

// string solution_info = 20;
inline void CpSolverResponse::clear_solution_info() {
  solution_info_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& CpSolverResponse::solution_info() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.solution_info)
  return solution_info_.GetNoArena();
}
inline void CpSolverResponse::set_solution_info(const ::std::string& value) {
  
  solution_info_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.solution_info)
}
#if LANG_CXX11
inline void CpSolverResponse::set_solution_info(::std::string&& value) {
  
  solution_info_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.sat.CpSolverResponse.solution_info)
}
#endif
inline void CpSolverResponse::set_solution_info(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  solution_info_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.sat.CpSolverResponse.solution_info)
}
inline void CpSolverResponse::set_solution_info(const char* value, size_t size) {
  
  solution_info_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.CpSolverResponse.solution_info)
}
inline ::std::string* CpSolverResponse::mutable_solution_info() {
  
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpSolverResponse.solution_info)
  return solution_info_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CpSolverResponse::release_solution_info() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpSolverResponse.solution_info)
  
  return solution_info_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CpSolverResponse::set_allocated_solution_info(::std::string* solution_info) {
  if (solution_info != nullptr) {
    
  } else {
    
  }
  solution_info_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), solution_info);
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpSolverResponse.solution_info)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace sat
}  // namespace operations_research

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy>() {
  return ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy>() {
  return ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::CpSolverStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::CpSolverStatus>() {
  return ::operations_research::sat::CpSolverStatus_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // PROTOBUF_INCLUDED_ortools_2fsat_2fcp_5fmodel_2eproto