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 GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fcp_5fmodel_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fcp_5fmodel_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#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 3019001 < 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/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.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
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[30]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fsat_2fcp_5fmodel_2eproto;
namespace operations_research {
namespace sat {
class AllDifferentConstraintProto;
struct AllDifferentConstraintProtoDefaultTypeInternal;
extern AllDifferentConstraintProtoDefaultTypeInternal _AllDifferentConstraintProto_default_instance_;
class AutomatonConstraintProto;
struct AutomatonConstraintProtoDefaultTypeInternal;
extern AutomatonConstraintProtoDefaultTypeInternal _AutomatonConstraintProto_default_instance_;
class BoolArgumentProto;
struct BoolArgumentProtoDefaultTypeInternal;
extern BoolArgumentProtoDefaultTypeInternal _BoolArgumentProto_default_instance_;
class CircuitConstraintProto;
struct CircuitConstraintProtoDefaultTypeInternal;
extern CircuitConstraintProtoDefaultTypeInternal _CircuitConstraintProto_default_instance_;
class ConstraintProto;
struct ConstraintProtoDefaultTypeInternal;
extern ConstraintProtoDefaultTypeInternal _ConstraintProto_default_instance_;
class CpModelProto;
struct CpModelProtoDefaultTypeInternal;
extern CpModelProtoDefaultTypeInternal _CpModelProto_default_instance_;
class CpObjectiveProto;
struct CpObjectiveProtoDefaultTypeInternal;
extern CpObjectiveProtoDefaultTypeInternal _CpObjectiveProto_default_instance_;
class CpSolverResponse;
struct CpSolverResponseDefaultTypeInternal;
extern CpSolverResponseDefaultTypeInternal _CpSolverResponse_default_instance_;
class CpSolverSolution;
struct CpSolverSolutionDefaultTypeInternal;
extern CpSolverSolutionDefaultTypeInternal _CpSolverSolution_default_instance_;
class CumulativeConstraintProto;
struct CumulativeConstraintProtoDefaultTypeInternal;
extern CumulativeConstraintProtoDefaultTypeInternal _CumulativeConstraintProto_default_instance_;
class DecisionStrategyProto;
struct DecisionStrategyProtoDefaultTypeInternal;
extern DecisionStrategyProtoDefaultTypeInternal _DecisionStrategyProto_default_instance_;
class DecisionStrategyProto_AffineTransformation;
struct DecisionStrategyProto_AffineTransformationDefaultTypeInternal;
extern DecisionStrategyProto_AffineTransformationDefaultTypeInternal _DecisionStrategyProto_AffineTransformation_default_instance_;
class DenseMatrixProto;
struct DenseMatrixProtoDefaultTypeInternal;
extern DenseMatrixProtoDefaultTypeInternal _DenseMatrixProto_default_instance_;
class ElementConstraintProto;
struct ElementConstraintProtoDefaultTypeInternal;
extern ElementConstraintProtoDefaultTypeInternal _ElementConstraintProto_default_instance_;
class FloatObjectiveProto;
struct FloatObjectiveProtoDefaultTypeInternal;
extern FloatObjectiveProtoDefaultTypeInternal _FloatObjectiveProto_default_instance_;
class IntegerVariableProto;
struct IntegerVariableProtoDefaultTypeInternal;
extern IntegerVariableProtoDefaultTypeInternal _IntegerVariableProto_default_instance_;
class IntervalConstraintProto;
struct IntervalConstraintProtoDefaultTypeInternal;
extern IntervalConstraintProtoDefaultTypeInternal _IntervalConstraintProto_default_instance_;
class InverseConstraintProto;
struct InverseConstraintProtoDefaultTypeInternal;
extern InverseConstraintProtoDefaultTypeInternal _InverseConstraintProto_default_instance_;
class LinearArgumentProto;
struct LinearArgumentProtoDefaultTypeInternal;
extern LinearArgumentProtoDefaultTypeInternal _LinearArgumentProto_default_instance_;
class LinearConstraintProto;
struct LinearConstraintProtoDefaultTypeInternal;
extern LinearConstraintProtoDefaultTypeInternal _LinearConstraintProto_default_instance_;
class LinearExpressionProto;
struct LinearExpressionProtoDefaultTypeInternal;
extern LinearExpressionProtoDefaultTypeInternal _LinearExpressionProto_default_instance_;
class ListOfVariablesProto;
struct ListOfVariablesProtoDefaultTypeInternal;
extern ListOfVariablesProtoDefaultTypeInternal _ListOfVariablesProto_default_instance_;
class NoOverlap2DConstraintProto;
struct NoOverlap2DConstraintProtoDefaultTypeInternal;
extern NoOverlap2DConstraintProtoDefaultTypeInternal _NoOverlap2DConstraintProto_default_instance_;
class NoOverlapConstraintProto;
struct NoOverlapConstraintProtoDefaultTypeInternal;
extern NoOverlapConstraintProtoDefaultTypeInternal _NoOverlapConstraintProto_default_instance_;
class PartialVariableAssignment;
struct PartialVariableAssignmentDefaultTypeInternal;
extern PartialVariableAssignmentDefaultTypeInternal _PartialVariableAssignment_default_instance_;
class ReservoirConstraintProto;
struct ReservoirConstraintProtoDefaultTypeInternal;
extern ReservoirConstraintProtoDefaultTypeInternal _ReservoirConstraintProto_default_instance_;
class RoutesConstraintProto;
struct RoutesConstraintProtoDefaultTypeInternal;
extern RoutesConstraintProtoDefaultTypeInternal _RoutesConstraintProto_default_instance_;
class SparsePermutationProto;
struct SparsePermutationProtoDefaultTypeInternal;
extern SparsePermutationProtoDefaultTypeInternal _SparsePermutationProto_default_instance_;
class SymmetryProto;
struct SymmetryProtoDefaultTypeInternal;
extern SymmetryProtoDefaultTypeInternal _SymmetryProto_default_instance_;
class TableConstraintProto;
struct TableConstraintProtoDefaultTypeInternal;
extern TableConstraintProtoDefaultTypeInternal _TableConstraintProto_default_instance_;
}  // namespace sat
}  // namespace operations_research
PROTOBUF_NAMESPACE_OPEN
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::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::CpSolverSolution* Arena::CreateMaybeMessage<::operations_research::sat::CpSolverSolution>(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::DenseMatrixProto* Arena::CreateMaybeMessage<::operations_research::sat::DenseMatrixProto>(Arena*);
template<> ::operations_research::sat::ElementConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::ElementConstraintProto>(Arena*);
template<> ::operations_research::sat::FloatObjectiveProto* Arena::CreateMaybeMessage<::operations_research::sat::FloatObjectiveProto>(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::LinearArgumentProto* Arena::CreateMaybeMessage<::operations_research::sat::LinearArgumentProto>(Arena*);
template<> ::operations_research::sat::LinearConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::LinearConstraintProto>(Arena*);
template<> ::operations_research::sat::LinearExpressionProto* Arena::CreateMaybeMessage<::operations_research::sat::LinearExpressionProto>(Arena*);
template<> ::operations_research::sat::ListOfVariablesProto* Arena::CreateMaybeMessage<::operations_research::sat::ListOfVariablesProto>(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::SparsePermutationProto* Arena::CreateMaybeMessage<::operations_research::sat::SparsePermutationProto>(Arena*);
template<> ::operations_research::sat::SymmetryProto* Arena::CreateMaybeMessage<::operations_research::sat::SymmetryProto>(Arena*);
template<> ::operations_research::sat::TableConstraintProto* Arena::CreateMaybeMessage<::operations_research::sat::TableConstraintProto>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace operations_research {
namespace sat {

enum DecisionStrategyProto_VariableSelectionStrategy : int {
  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<int32_t>::min(),
  DecisionStrategyProto_VariableSelectionStrategy_DecisionStrategyProto_VariableSelectionStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool DecisionStrategyProto_VariableSelectionStrategy_IsValid(int value);
constexpr DecisionStrategyProto_VariableSelectionStrategy DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MIN = DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_FIRST;
constexpr DecisionStrategyProto_VariableSelectionStrategy DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MAX = DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_MAX_DOMAIN_SIZE;
constexpr int DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_ARRAYSIZE = DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DecisionStrategyProto_VariableSelectionStrategy_descriptor();
template<typename T>
inline const std::string& DecisionStrategyProto_VariableSelectionStrategy_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DecisionStrategyProto_VariableSelectionStrategy>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DecisionStrategyProto_VariableSelectionStrategy_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DecisionStrategyProto_VariableSelectionStrategy_descriptor(), enum_t_value);
}
inline bool DecisionStrategyProto_VariableSelectionStrategy_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DecisionStrategyProto_VariableSelectionStrategy* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DecisionStrategyProto_VariableSelectionStrategy>(
    DecisionStrategyProto_VariableSelectionStrategy_descriptor(), name, value);
}
enum DecisionStrategyProto_DomainReductionStrategy : int {
  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_SELECT_MEDIAN_VALUE = 4,
  DecisionStrategyProto_DomainReductionStrategy_DecisionStrategyProto_DomainReductionStrategy_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  DecisionStrategyProto_DomainReductionStrategy_DecisionStrategyProto_DomainReductionStrategy_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool DecisionStrategyProto_DomainReductionStrategy_IsValid(int value);
constexpr DecisionStrategyProto_DomainReductionStrategy DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MIN = DecisionStrategyProto_DomainReductionStrategy_SELECT_MIN_VALUE;
constexpr DecisionStrategyProto_DomainReductionStrategy DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MAX = DecisionStrategyProto_DomainReductionStrategy_SELECT_MEDIAN_VALUE;
constexpr int DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_ARRAYSIZE = DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DecisionStrategyProto_DomainReductionStrategy_descriptor();
template<typename T>
inline const std::string& DecisionStrategyProto_DomainReductionStrategy_Name(T enum_t_value) {
  static_assert(::std::is_same<T, DecisionStrategyProto_DomainReductionStrategy>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function DecisionStrategyProto_DomainReductionStrategy_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    DecisionStrategyProto_DomainReductionStrategy_descriptor(), enum_t_value);
}
inline bool DecisionStrategyProto_DomainReductionStrategy_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DecisionStrategyProto_DomainReductionStrategy* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DecisionStrategyProto_DomainReductionStrategy>(
    DecisionStrategyProto_DomainReductionStrategy_descriptor(), name, value);
}
enum CpSolverStatus : int {
  UNKNOWN = 0,
  MODEL_INVALID = 1,
  FEASIBLE = 2,
  INFEASIBLE = 3,
  OPTIMAL = 4,
  CpSolverStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::min(),
  CpSolverStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<int32_t>::max()
};
bool CpSolverStatus_IsValid(int value);
constexpr CpSolverStatus CpSolverStatus_MIN = UNKNOWN;
constexpr CpSolverStatus CpSolverStatus_MAX = OPTIMAL;
constexpr int CpSolverStatus_ARRAYSIZE = CpSolverStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CpSolverStatus_descriptor();
template<typename T>
inline const std::string& CpSolverStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CpSolverStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CpSolverStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CpSolverStatus_descriptor(), enum_t_value);
}
inline bool CpSolverStatus_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CpSolverStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CpSolverStatus>(
    CpSolverStatus_descriptor(), name, value);
}
// ===================================================================

class IntegerVariableProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.IntegerVariableProto) */ {
 public:
  inline IntegerVariableProto() : IntegerVariableProto(nullptr) {}
  ~IntegerVariableProto() override;
  explicit constexpr IntegerVariableProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  IntegerVariableProto(const IntegerVariableProto& from);
  IntegerVariableProto(IntegerVariableProto&& from) noexcept
    : IntegerVariableProto() {
    *this = ::std::move(from);
  }

  inline IntegerVariableProto& operator=(const IntegerVariableProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline IntegerVariableProto& operator=(IntegerVariableProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IntegerVariableProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const IntegerVariableProto* internal_default_instance() {
    return reinterpret_cast<const IntegerVariableProto*>(
               &_IntegerVariableProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(IntegerVariableProto& a, IntegerVariableProto& b) {
    a.Swap(&b);
  }
  inline void Swap(IntegerVariableProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IntegerVariableProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  IntegerVariableProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IntegerVariableProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IntegerVariableProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const IntegerVariableProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.IntegerVariableProto";
  }
  protected:
  explicit IntegerVariableProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kDomainFieldNumber = 2,
    kNameFieldNumber = 1,
  };
  // repeated int64 domain = 2;
  int domain_size() const;
  private:
  int _internal_domain_size() const;
  public:
  void clear_domain();
  private:
  int64_t _internal_domain(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_domain() const;
  void _internal_add_domain(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_domain();
  public:
  int64_t domain(int index) const;
  void set_domain(int index, int64_t value);
  void add_domain(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      domain() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_domain();

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > domain_;
  mutable std::atomic<int> _domain_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class BoolArgumentProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.BoolArgumentProto) */ {
 public:
  inline BoolArgumentProto() : BoolArgumentProto(nullptr) {}
  ~BoolArgumentProto() override;
  explicit constexpr BoolArgumentProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BoolArgumentProto(const BoolArgumentProto& from);
  BoolArgumentProto(BoolArgumentProto&& from) noexcept
    : BoolArgumentProto() {
    *this = ::std::move(from);
  }

  inline BoolArgumentProto& operator=(const BoolArgumentProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoolArgumentProto& operator=(BoolArgumentProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const BoolArgumentProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const BoolArgumentProto* internal_default_instance() {
    return reinterpret_cast<const BoolArgumentProto*>(
               &_BoolArgumentProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(BoolArgumentProto& a, BoolArgumentProto& b) {
    a.Swap(&b);
  }
  inline void Swap(BoolArgumentProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BoolArgumentProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  BoolArgumentProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<BoolArgumentProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const BoolArgumentProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const BoolArgumentProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.BoolArgumentProto";
  }
  protected:
  explicit BoolArgumentProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kLiteralsFieldNumber = 1,
  };
  // repeated int32 literals = 1;
  int literals_size() const;
  private:
  int _internal_literals_size() const;
  public:
  void clear_literals();
  private:
  int32_t _internal_literals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_literals() const;
  void _internal_add_literals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_literals();
  public:
  int32_t literals(int index) const;
  void set_literals(int index, int32_t value);
  void add_literals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      literals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_literals();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > literals_;
  mutable std::atomic<int> _literals_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class LinearExpressionProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.LinearExpressionProto) */ {
 public:
  inline LinearExpressionProto() : LinearExpressionProto(nullptr) {}
  ~LinearExpressionProto() override;
  explicit constexpr LinearExpressionProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  LinearExpressionProto(const LinearExpressionProto& from);
  LinearExpressionProto(LinearExpressionProto&& from) noexcept
    : LinearExpressionProto() {
    *this = ::std::move(from);
  }

  inline LinearExpressionProto& operator=(const LinearExpressionProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinearExpressionProto& operator=(LinearExpressionProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinearExpressionProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinearExpressionProto* internal_default_instance() {
    return reinterpret_cast<const LinearExpressionProto*>(
               &_LinearExpressionProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(LinearExpressionProto& a, LinearExpressionProto& b) {
    a.Swap(&b);
  }
  inline void Swap(LinearExpressionProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinearExpressionProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LinearExpressionProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinearExpressionProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinearExpressionProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LinearExpressionProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinearExpressionProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.LinearExpressionProto";
  }
  protected:
  explicit LinearExpressionProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVarsFieldNumber = 1,
    kCoeffsFieldNumber = 2,
    kOffsetFieldNumber = 3,
  };
  // repeated int32 vars = 1;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // repeated int64 coeffs = 2;
  int coeffs_size() const;
  private:
  int _internal_coeffs_size() const;
  public:
  void clear_coeffs();
  private:
  int64_t _internal_coeffs(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_coeffs() const;
  void _internal_add_coeffs(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_coeffs();
  public:
  int64_t coeffs(int index) const;
  void set_coeffs(int index, int64_t value);
  void add_coeffs(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      coeffs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_coeffs();

  // int64 offset = 3;
  void clear_offset();
  int64_t offset() const;
  void set_offset(int64_t value);
  private:
  int64_t _internal_offset() const;
  void _internal_set_offset(int64_t value);
  public:

  // @@protoc_insertion_point(class_scope:operations_research.sat.LinearExpressionProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > coeffs_;
  mutable std::atomic<int> _coeffs_cached_byte_size_;
  int64_t offset_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class LinearArgumentProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.LinearArgumentProto) */ {
 public:
  inline LinearArgumentProto() : LinearArgumentProto(nullptr) {}
  ~LinearArgumentProto() override;
  explicit constexpr LinearArgumentProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  LinearArgumentProto(const LinearArgumentProto& from);
  LinearArgumentProto(LinearArgumentProto&& from) noexcept
    : LinearArgumentProto() {
    *this = ::std::move(from);
  }

  inline LinearArgumentProto& operator=(const LinearArgumentProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinearArgumentProto& operator=(LinearArgumentProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinearArgumentProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinearArgumentProto* internal_default_instance() {
    return reinterpret_cast<const LinearArgumentProto*>(
               &_LinearArgumentProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(LinearArgumentProto& a, LinearArgumentProto& b) {
    a.Swap(&b);
  }
  inline void Swap(LinearArgumentProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinearArgumentProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LinearArgumentProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinearArgumentProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinearArgumentProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LinearArgumentProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(LinearArgumentProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.LinearArgumentProto";
  }
  protected:
  explicit LinearArgumentProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kExprsFieldNumber = 2,
    kTargetFieldNumber = 1,
  };
  // repeated .operations_research.sat.LinearExpressionProto exprs = 2;
  int exprs_size() const;
  private:
  int _internal_exprs_size() const;
  public:
  void clear_exprs();
  ::operations_research::sat::LinearExpressionProto* mutable_exprs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >*
      mutable_exprs();
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_exprs(int index) const;
  ::operations_research::sat::LinearExpressionProto* _internal_add_exprs();
  public:
  const ::operations_research::sat::LinearExpressionProto& exprs(int index) const;
  ::operations_research::sat::LinearExpressionProto* add_exprs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >&
      exprs() const;

  // .operations_research.sat.LinearExpressionProto target = 1;
  bool has_target() const;
  private:
  bool _internal_has_target() const;
  public:
  void clear_target();
  const ::operations_research::sat::LinearExpressionProto& target() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearExpressionProto* release_target();
  ::operations_research::sat::LinearExpressionProto* mutable_target();
  void set_allocated_target(::operations_research::sat::LinearExpressionProto* target);
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_target() const;
  ::operations_research::sat::LinearExpressionProto* _internal_mutable_target();
  public:
  void unsafe_arena_set_allocated_target(
      ::operations_research::sat::LinearExpressionProto* target);
  ::operations_research::sat::LinearExpressionProto* unsafe_arena_release_target();

  // @@protoc_insertion_point(class_scope:operations_research.sat.LinearArgumentProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto > exprs_;
  ::operations_research::sat::LinearExpressionProto* target_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class AllDifferentConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.AllDifferentConstraintProto) */ {
 public:
  inline AllDifferentConstraintProto() : AllDifferentConstraintProto(nullptr) {}
  ~AllDifferentConstraintProto() override;
  explicit constexpr AllDifferentConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AllDifferentConstraintProto(const AllDifferentConstraintProto& from);
  AllDifferentConstraintProto(AllDifferentConstraintProto&& from) noexcept
    : AllDifferentConstraintProto() {
    *this = ::std::move(from);
  }

  inline AllDifferentConstraintProto& operator=(const AllDifferentConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline AllDifferentConstraintProto& operator=(AllDifferentConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AllDifferentConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const AllDifferentConstraintProto* internal_default_instance() {
    return reinterpret_cast<const AllDifferentConstraintProto*>(
               &_AllDifferentConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(AllDifferentConstraintProto& a, AllDifferentConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(AllDifferentConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AllDifferentConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AllDifferentConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AllDifferentConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AllDifferentConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const AllDifferentConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.AllDifferentConstraintProto";
  }
  protected:
  explicit AllDifferentConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kExprsFieldNumber = 1,
  };
  // repeated .operations_research.sat.LinearExpressionProto exprs = 1;
  int exprs_size() const;
  private:
  int _internal_exprs_size() const;
  public:
  void clear_exprs();
  ::operations_research::sat::LinearExpressionProto* mutable_exprs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >*
      mutable_exprs();
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_exprs(int index) const;
  ::operations_research::sat::LinearExpressionProto* _internal_add_exprs();
  public:
  const ::operations_research::sat::LinearExpressionProto& exprs(int index) const;
  ::operations_research::sat::LinearExpressionProto* add_exprs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >&
      exprs() const;

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto > exprs_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class LinearConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.LinearConstraintProto) */ {
 public:
  inline LinearConstraintProto() : LinearConstraintProto(nullptr) {}
  ~LinearConstraintProto() override;
  explicit constexpr LinearConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  LinearConstraintProto(const LinearConstraintProto& from);
  LinearConstraintProto(LinearConstraintProto&& from) noexcept
    : LinearConstraintProto() {
    *this = ::std::move(from);
  }

  inline LinearConstraintProto& operator=(const LinearConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline LinearConstraintProto& operator=(LinearConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const LinearConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const LinearConstraintProto* internal_default_instance() {
    return reinterpret_cast<const LinearConstraintProto*>(
               &_LinearConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(LinearConstraintProto& a, LinearConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(LinearConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(LinearConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  LinearConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<LinearConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const LinearConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const LinearConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.LinearConstraintProto";
  }
  protected:
  explicit LinearConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVarsFieldNumber = 1,
    kCoeffsFieldNumber = 2,
    kDomainFieldNumber = 3,
  };
  // repeated int32 vars = 1;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // repeated int64 coeffs = 2;
  int coeffs_size() const;
  private:
  int _internal_coeffs_size() const;
  public:
  void clear_coeffs();
  private:
  int64_t _internal_coeffs(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_coeffs() const;
  void _internal_add_coeffs(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_coeffs();
  public:
  int64_t coeffs(int index) const;
  void set_coeffs(int index, int64_t value);
  void add_coeffs(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      coeffs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_coeffs();

  // repeated int64 domain = 3;
  int domain_size() const;
  private:
  int _internal_domain_size() const;
  public:
  void clear_domain();
  private:
  int64_t _internal_domain(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_domain() const;
  void _internal_add_domain(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_domain();
  public:
  int64_t domain(int index) const;
  void set_domain(int index, int64_t value);
  void add_domain(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      domain() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_domain();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > coeffs_;
  mutable std::atomic<int> _coeffs_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > domain_;
  mutable std::atomic<int> _domain_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class ElementConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.ElementConstraintProto) */ {
 public:
  inline ElementConstraintProto() : ElementConstraintProto(nullptr) {}
  ~ElementConstraintProto() override;
  explicit constexpr ElementConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ElementConstraintProto(const ElementConstraintProto& from);
  ElementConstraintProto(ElementConstraintProto&& from) noexcept
    : ElementConstraintProto() {
    *this = ::std::move(from);
  }

  inline ElementConstraintProto& operator=(const ElementConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ElementConstraintProto& operator=(ElementConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ElementConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ElementConstraintProto* internal_default_instance() {
    return reinterpret_cast<const ElementConstraintProto*>(
               &_ElementConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(ElementConstraintProto& a, ElementConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(ElementConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ElementConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ElementConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ElementConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ElementConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ElementConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.ElementConstraintProto";
  }
  protected:
  explicit ElementConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVarsFieldNumber = 3,
    kIndexFieldNumber = 1,
    kTargetFieldNumber = 2,
  };
  // repeated int32 vars = 3;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // int32 index = 1;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

  // int32 target = 2;
  void clear_target();
  int32_t target() const;
  void set_target(int32_t value);
  private:
  int32_t _internal_target() const;
  void _internal_set_target(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  int32_t index_;
  int32_t target_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class IntervalConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.IntervalConstraintProto) */ {
 public:
  inline IntervalConstraintProto() : IntervalConstraintProto(nullptr) {}
  ~IntervalConstraintProto() override;
  explicit constexpr IntervalConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  IntervalConstraintProto(const IntervalConstraintProto& from);
  IntervalConstraintProto(IntervalConstraintProto&& from) noexcept
    : IntervalConstraintProto() {
    *this = ::std::move(from);
  }

  inline IntervalConstraintProto& operator=(const IntervalConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline IntervalConstraintProto& operator=(IntervalConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const IntervalConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const IntervalConstraintProto* internal_default_instance() {
    return reinterpret_cast<const IntervalConstraintProto*>(
               &_IntervalConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(IntervalConstraintProto& a, IntervalConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(IntervalConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(IntervalConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  IntervalConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<IntervalConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const IntervalConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const IntervalConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.IntervalConstraintProto";
  }
  protected:
  explicit IntervalConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kStartFieldNumber = 4,
    kEndFieldNumber = 5,
    kSizeFieldNumber = 6,
  };
  // .operations_research.sat.LinearExpressionProto start = 4;
  bool has_start() const;
  private:
  bool _internal_has_start() const;
  public:
  void clear_start();
  const ::operations_research::sat::LinearExpressionProto& start() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearExpressionProto* release_start();
  ::operations_research::sat::LinearExpressionProto* mutable_start();
  void set_allocated_start(::operations_research::sat::LinearExpressionProto* start);
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_start() const;
  ::operations_research::sat::LinearExpressionProto* _internal_mutable_start();
  public:
  void unsafe_arena_set_allocated_start(
      ::operations_research::sat::LinearExpressionProto* start);
  ::operations_research::sat::LinearExpressionProto* unsafe_arena_release_start();

  // .operations_research.sat.LinearExpressionProto end = 5;
  bool has_end() const;
  private:
  bool _internal_has_end() const;
  public:
  void clear_end();
  const ::operations_research::sat::LinearExpressionProto& end() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearExpressionProto* release_end();
  ::operations_research::sat::LinearExpressionProto* mutable_end();
  void set_allocated_end(::operations_research::sat::LinearExpressionProto* end);
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_end() const;
  ::operations_research::sat::LinearExpressionProto* _internal_mutable_end();
  public:
  void unsafe_arena_set_allocated_end(
      ::operations_research::sat::LinearExpressionProto* end);
  ::operations_research::sat::LinearExpressionProto* unsafe_arena_release_end();

  // .operations_research.sat.LinearExpressionProto size = 6;
  bool has_size() const;
  private:
  bool _internal_has_size() const;
  public:
  void clear_size();
  const ::operations_research::sat::LinearExpressionProto& size() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearExpressionProto* release_size();
  ::operations_research::sat::LinearExpressionProto* mutable_size();
  void set_allocated_size(::operations_research::sat::LinearExpressionProto* size);
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_size() const;
  ::operations_research::sat::LinearExpressionProto* _internal_mutable_size();
  public:
  void unsafe_arena_set_allocated_size(
      ::operations_research::sat::LinearExpressionProto* size);
  ::operations_research::sat::LinearExpressionProto* unsafe_arena_release_size();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::operations_research::sat::LinearExpressionProto* start_;
  ::operations_research::sat::LinearExpressionProto* end_;
  ::operations_research::sat::LinearExpressionProto* size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class NoOverlapConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.NoOverlapConstraintProto) */ {
 public:
  inline NoOverlapConstraintProto() : NoOverlapConstraintProto(nullptr) {}
  ~NoOverlapConstraintProto() override;
  explicit constexpr NoOverlapConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NoOverlapConstraintProto(const NoOverlapConstraintProto& from);
  NoOverlapConstraintProto(NoOverlapConstraintProto&& from) noexcept
    : NoOverlapConstraintProto() {
    *this = ::std::move(from);
  }

  inline NoOverlapConstraintProto& operator=(const NoOverlapConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline NoOverlapConstraintProto& operator=(NoOverlapConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NoOverlapConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const NoOverlapConstraintProto* internal_default_instance() {
    return reinterpret_cast<const NoOverlapConstraintProto*>(
               &_NoOverlapConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(NoOverlapConstraintProto& a, NoOverlapConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(NoOverlapConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NoOverlapConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NoOverlapConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NoOverlapConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NoOverlapConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const NoOverlapConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.NoOverlapConstraintProto";
  }
  protected:
  explicit NoOverlapConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIntervalsFieldNumber = 1,
  };
  // repeated int32 intervals = 1;
  int intervals_size() const;
  private:
  int _internal_intervals_size() const;
  public:
  void clear_intervals();
  private:
  int32_t _internal_intervals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_intervals() const;
  void _internal_add_intervals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_intervals();
  public:
  int32_t intervals(int index) const;
  void set_intervals(int index, int32_t value);
  void add_intervals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      intervals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_intervals();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > intervals_;
  mutable std::atomic<int> _intervals_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class NoOverlap2DConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.NoOverlap2DConstraintProto) */ {
 public:
  inline NoOverlap2DConstraintProto() : NoOverlap2DConstraintProto(nullptr) {}
  ~NoOverlap2DConstraintProto() override;
  explicit constexpr NoOverlap2DConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NoOverlap2DConstraintProto(const NoOverlap2DConstraintProto& from);
  NoOverlap2DConstraintProto(NoOverlap2DConstraintProto&& from) noexcept
    : NoOverlap2DConstraintProto() {
    *this = ::std::move(from);
  }

  inline NoOverlap2DConstraintProto& operator=(const NoOverlap2DConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline NoOverlap2DConstraintProto& operator=(NoOverlap2DConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NoOverlap2DConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const NoOverlap2DConstraintProto* internal_default_instance() {
    return reinterpret_cast<const NoOverlap2DConstraintProto*>(
               &_NoOverlap2DConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(NoOverlap2DConstraintProto& a, NoOverlap2DConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(NoOverlap2DConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NoOverlap2DConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  NoOverlap2DConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<NoOverlap2DConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NoOverlap2DConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const NoOverlap2DConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.NoOverlap2DConstraintProto";
  }
  protected:
  explicit NoOverlap2DConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kXIntervalsFieldNumber = 1,
    kYIntervalsFieldNumber = 2,
    kBoxesWithNullAreaCanOverlapFieldNumber = 3,
  };
  // repeated int32 x_intervals = 1;
  int x_intervals_size() const;
  private:
  int _internal_x_intervals_size() const;
  public:
  void clear_x_intervals();
  private:
  int32_t _internal_x_intervals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_x_intervals() const;
  void _internal_add_x_intervals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_x_intervals();
  public:
  int32_t x_intervals(int index) const;
  void set_x_intervals(int index, int32_t value);
  void add_x_intervals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      x_intervals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_x_intervals();

  // repeated int32 y_intervals = 2;
  int y_intervals_size() const;
  private:
  int _internal_y_intervals_size() const;
  public:
  void clear_y_intervals();
  private:
  int32_t _internal_y_intervals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_y_intervals() const;
  void _internal_add_y_intervals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_y_intervals();
  public:
  int32_t y_intervals(int index) const;
  void set_y_intervals(int index, int32_t value);
  void add_y_intervals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      y_intervals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_y_intervals();

  // bool boxes_with_null_area_can_overlap = 3;
  void clear_boxes_with_null_area_can_overlap();
  bool boxes_with_null_area_can_overlap() const;
  void set_boxes_with_null_area_can_overlap(bool value);
  private:
  bool _internal_boxes_with_null_area_can_overlap() const;
  void _internal_set_boxes_with_null_area_can_overlap(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > x_intervals_;
  mutable std::atomic<int> _x_intervals_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > y_intervals_;
  mutable std::atomic<int> _y_intervals_cached_byte_size_;
  bool boxes_with_null_area_can_overlap_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CumulativeConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CumulativeConstraintProto) */ {
 public:
  inline CumulativeConstraintProto() : CumulativeConstraintProto(nullptr) {}
  ~CumulativeConstraintProto() override;
  explicit constexpr CumulativeConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CumulativeConstraintProto(const CumulativeConstraintProto& from);
  CumulativeConstraintProto(CumulativeConstraintProto&& from) noexcept
    : CumulativeConstraintProto() {
    *this = ::std::move(from);
  }

  inline CumulativeConstraintProto& operator=(const CumulativeConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CumulativeConstraintProto& operator=(CumulativeConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CumulativeConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const CumulativeConstraintProto* internal_default_instance() {
    return reinterpret_cast<const CumulativeConstraintProto*>(
               &_CumulativeConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(CumulativeConstraintProto& a, CumulativeConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(CumulativeConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CumulativeConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CumulativeConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CumulativeConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CumulativeConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CumulativeConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.CumulativeConstraintProto";
  }
  protected:
  explicit CumulativeConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kIntervalsFieldNumber = 2,
    kDemandsFieldNumber = 3,
    kCapacityFieldNumber = 1,
  };
  // repeated int32 intervals = 2;
  int intervals_size() const;
  private:
  int _internal_intervals_size() const;
  public:
  void clear_intervals();
  private:
  int32_t _internal_intervals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_intervals() const;
  void _internal_add_intervals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_intervals();
  public:
  int32_t intervals(int index) const;
  void set_intervals(int index, int32_t value);
  void add_intervals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      intervals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_intervals();

  // repeated .operations_research.sat.LinearExpressionProto demands = 3;
  int demands_size() const;
  private:
  int _internal_demands_size() const;
  public:
  void clear_demands();
  ::operations_research::sat::LinearExpressionProto* mutable_demands(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >*
      mutable_demands();
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_demands(int index) const;
  ::operations_research::sat::LinearExpressionProto* _internal_add_demands();
  public:
  const ::operations_research::sat::LinearExpressionProto& demands(int index) const;
  ::operations_research::sat::LinearExpressionProto* add_demands();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >&
      demands() const;

  // .operations_research.sat.LinearExpressionProto capacity = 1;
  bool has_capacity() const;
  private:
  bool _internal_has_capacity() const;
  public:
  void clear_capacity();
  const ::operations_research::sat::LinearExpressionProto& capacity() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearExpressionProto* release_capacity();
  ::operations_research::sat::LinearExpressionProto* mutable_capacity();
  void set_allocated_capacity(::operations_research::sat::LinearExpressionProto* capacity);
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_capacity() const;
  ::operations_research::sat::LinearExpressionProto* _internal_mutable_capacity();
  public:
  void unsafe_arena_set_allocated_capacity(
      ::operations_research::sat::LinearExpressionProto* capacity);
  ::operations_research::sat::LinearExpressionProto* unsafe_arena_release_capacity();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > intervals_;
  mutable std::atomic<int> _intervals_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto > demands_;
  ::operations_research::sat::LinearExpressionProto* capacity_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class ReservoirConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.ReservoirConstraintProto) */ {
 public:
  inline ReservoirConstraintProto() : ReservoirConstraintProto(nullptr) {}
  ~ReservoirConstraintProto() override;
  explicit constexpr ReservoirConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ReservoirConstraintProto(const ReservoirConstraintProto& from);
  ReservoirConstraintProto(ReservoirConstraintProto&& from) noexcept
    : ReservoirConstraintProto() {
    *this = ::std::move(from);
  }

  inline ReservoirConstraintProto& operator=(const ReservoirConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReservoirConstraintProto& operator=(ReservoirConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReservoirConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReservoirConstraintProto* internal_default_instance() {
    return reinterpret_cast<const ReservoirConstraintProto*>(
               &_ReservoirConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(ReservoirConstraintProto& a, ReservoirConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(ReservoirConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReservoirConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ReservoirConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ReservoirConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReservoirConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReservoirConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.ReservoirConstraintProto";
  }
  protected:
  explicit ReservoirConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTimeExprsFieldNumber = 3,
    kLevelChangesFieldNumber = 4,
    kActiveLiteralsFieldNumber = 5,
    kMinLevelFieldNumber = 1,
    kMaxLevelFieldNumber = 2,
  };
  // repeated .operations_research.sat.LinearExpressionProto time_exprs = 3;
  int time_exprs_size() const;
  private:
  int _internal_time_exprs_size() const;
  public:
  void clear_time_exprs();
  ::operations_research::sat::LinearExpressionProto* mutable_time_exprs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >*
      mutable_time_exprs();
  private:
  const ::operations_research::sat::LinearExpressionProto& _internal_time_exprs(int index) const;
  ::operations_research::sat::LinearExpressionProto* _internal_add_time_exprs();
  public:
  const ::operations_research::sat::LinearExpressionProto& time_exprs(int index) const;
  ::operations_research::sat::LinearExpressionProto* add_time_exprs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >&
      time_exprs() const;

  // repeated int64 level_changes = 4;
  int level_changes_size() const;
  private:
  int _internal_level_changes_size() const;
  public:
  void clear_level_changes();
  private:
  int64_t _internal_level_changes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_level_changes() const;
  void _internal_add_level_changes(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_level_changes();
  public:
  int64_t level_changes(int index) const;
  void set_level_changes(int index, int64_t value);
  void add_level_changes(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      level_changes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_level_changes();

  // repeated int32 active_literals = 5;
  int active_literals_size() const;
  private:
  int _internal_active_literals_size() const;
  public:
  void clear_active_literals();
  private:
  int32_t _internal_active_literals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_active_literals() const;
  void _internal_add_active_literals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_active_literals();
  public:
  int32_t active_literals(int index) const;
  void set_active_literals(int index, int32_t value);
  void add_active_literals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      active_literals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_active_literals();

  // int64 min_level = 1;
  void clear_min_level();
  int64_t min_level() const;
  void set_min_level(int64_t value);
  private:
  int64_t _internal_min_level() const;
  void _internal_set_min_level(int64_t value);
  public:

  // int64 max_level = 2;
  void clear_max_level();
  int64_t max_level() const;
  void set_max_level(int64_t value);
  private:
  int64_t _internal_max_level() const;
  void _internal_set_max_level(int64_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto > time_exprs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > level_changes_;
  mutable std::atomic<int> _level_changes_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > active_literals_;
  mutable std::atomic<int> _active_literals_cached_byte_size_;
  int64_t min_level_;
  int64_t max_level_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CircuitConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CircuitConstraintProto) */ {
 public:
  inline CircuitConstraintProto() : CircuitConstraintProto(nullptr) {}
  ~CircuitConstraintProto() override;
  explicit constexpr CircuitConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CircuitConstraintProto(const CircuitConstraintProto& from);
  CircuitConstraintProto(CircuitConstraintProto&& from) noexcept
    : CircuitConstraintProto() {
    *this = ::std::move(from);
  }

  inline CircuitConstraintProto& operator=(const CircuitConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CircuitConstraintProto& operator=(CircuitConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CircuitConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const CircuitConstraintProto* internal_default_instance() {
    return reinterpret_cast<const CircuitConstraintProto*>(
               &_CircuitConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CircuitConstraintProto& a, CircuitConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(CircuitConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CircuitConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CircuitConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CircuitConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CircuitConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CircuitConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.CircuitConstraintProto";
  }
  protected:
  explicit CircuitConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTailsFieldNumber = 3,
    kHeadsFieldNumber = 4,
    kLiteralsFieldNumber = 5,
  };
  // repeated int32 tails = 3;
  int tails_size() const;
  private:
  int _internal_tails_size() const;
  public:
  void clear_tails();
  private:
  int32_t _internal_tails(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_tails() const;
  void _internal_add_tails(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_tails();
  public:
  int32_t tails(int index) const;
  void set_tails(int index, int32_t value);
  void add_tails(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      tails() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_tails();

  // repeated int32 heads = 4;
  int heads_size() const;
  private:
  int _internal_heads_size() const;
  public:
  void clear_heads();
  private:
  int32_t _internal_heads(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_heads() const;
  void _internal_add_heads(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_heads();
  public:
  int32_t heads(int index) const;
  void set_heads(int index, int32_t value);
  void add_heads(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      heads() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_heads();

  // repeated int32 literals = 5;
  int literals_size() const;
  private:
  int _internal_literals_size() const;
  public:
  void clear_literals();
  private:
  int32_t _internal_literals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_literals() const;
  void _internal_add_literals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_literals();
  public:
  int32_t literals(int index) const;
  void set_literals(int index, int32_t value);
  void add_literals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      literals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_literals();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > tails_;
  mutable std::atomic<int> _tails_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > heads_;
  mutable std::atomic<int> _heads_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > literals_;
  mutable std::atomic<int> _literals_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class RoutesConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.RoutesConstraintProto) */ {
 public:
  inline RoutesConstraintProto() : RoutesConstraintProto(nullptr) {}
  ~RoutesConstraintProto() override;
  explicit constexpr RoutesConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RoutesConstraintProto(const RoutesConstraintProto& from);
  RoutesConstraintProto(RoutesConstraintProto&& from) noexcept
    : RoutesConstraintProto() {
    *this = ::std::move(from);
  }

  inline RoutesConstraintProto& operator=(const RoutesConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline RoutesConstraintProto& operator=(RoutesConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RoutesConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const RoutesConstraintProto* internal_default_instance() {
    return reinterpret_cast<const RoutesConstraintProto*>(
               &_RoutesConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(RoutesConstraintProto& a, RoutesConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(RoutesConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RoutesConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  RoutesConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<RoutesConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RoutesConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RoutesConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.RoutesConstraintProto";
  }
  protected:
  explicit RoutesConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kTailsFieldNumber = 1,
    kHeadsFieldNumber = 2,
    kLiteralsFieldNumber = 3,
    kDemandsFieldNumber = 4,
    kCapacityFieldNumber = 5,
  };
  // repeated int32 tails = 1;
  int tails_size() const;
  private:
  int _internal_tails_size() const;
  public:
  void clear_tails();
  private:
  int32_t _internal_tails(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_tails() const;
  void _internal_add_tails(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_tails();
  public:
  int32_t tails(int index) const;
  void set_tails(int index, int32_t value);
  void add_tails(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      tails() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_tails();

  // repeated int32 heads = 2;
  int heads_size() const;
  private:
  int _internal_heads_size() const;
  public:
  void clear_heads();
  private:
  int32_t _internal_heads(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_heads() const;
  void _internal_add_heads(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_heads();
  public:
  int32_t heads(int index) const;
  void set_heads(int index, int32_t value);
  void add_heads(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      heads() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_heads();

  // repeated int32 literals = 3;
  int literals_size() const;
  private:
  int _internal_literals_size() const;
  public:
  void clear_literals();
  private:
  int32_t _internal_literals(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_literals() const;
  void _internal_add_literals(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_literals();
  public:
  int32_t literals(int index) const;
  void set_literals(int index, int32_t value);
  void add_literals(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      literals() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_literals();

  // repeated int32 demands = 4;
  int demands_size() const;
  private:
  int _internal_demands_size() const;
  public:
  void clear_demands();
  private:
  int32_t _internal_demands(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_demands() const;
  void _internal_add_demands(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_demands();
  public:
  int32_t demands(int index) const;
  void set_demands(int index, int32_t value);
  void add_demands(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      demands() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_demands();

  // int64 capacity = 5;
  void clear_capacity();
  int64_t capacity() const;
  void set_capacity(int64_t value);
  private:
  int64_t _internal_capacity() const;
  void _internal_set_capacity(int64_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > tails_;
  mutable std::atomic<int> _tails_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > heads_;
  mutable std::atomic<int> _heads_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > literals_;
  mutable std::atomic<int> _literals_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > demands_;
  mutable std::atomic<int> _demands_cached_byte_size_;
  int64_t capacity_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class TableConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.TableConstraintProto) */ {
 public:
  inline TableConstraintProto() : TableConstraintProto(nullptr) {}
  ~TableConstraintProto() override;
  explicit constexpr TableConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TableConstraintProto(const TableConstraintProto& from);
  TableConstraintProto(TableConstraintProto&& from) noexcept
    : TableConstraintProto() {
    *this = ::std::move(from);
  }

  inline TableConstraintProto& operator=(const TableConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline TableConstraintProto& operator=(TableConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TableConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const TableConstraintProto* internal_default_instance() {
    return reinterpret_cast<const TableConstraintProto*>(
               &_TableConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(TableConstraintProto& a, TableConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(TableConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TableConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  TableConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<TableConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TableConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const TableConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.TableConstraintProto";
  }
  protected:
  explicit TableConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVarsFieldNumber = 1,
    kValuesFieldNumber = 2,
    kNegatedFieldNumber = 3,
  };
  // repeated int32 vars = 1;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // repeated int64 values = 2;
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  private:
  int64_t _internal_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_values() const;
  void _internal_add_values(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_values();
  public:
  int64_t values(int index) const;
  void set_values(int index, int64_t value);
  void add_values(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_values();

  // bool negated = 3;
  void clear_negated();
  bool negated() const;
  void set_negated(bool value);
  private:
  bool _internal_negated() const;
  void _internal_set_negated(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > values_;
  mutable std::atomic<int> _values_cached_byte_size_;
  bool negated_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class InverseConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.InverseConstraintProto) */ {
 public:
  inline InverseConstraintProto() : InverseConstraintProto(nullptr) {}
  ~InverseConstraintProto() override;
  explicit constexpr InverseConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  InverseConstraintProto(const InverseConstraintProto& from);
  InverseConstraintProto(InverseConstraintProto&& from) noexcept
    : InverseConstraintProto() {
    *this = ::std::move(from);
  }

  inline InverseConstraintProto& operator=(const InverseConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline InverseConstraintProto& operator=(InverseConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const InverseConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const InverseConstraintProto* internal_default_instance() {
    return reinterpret_cast<const InverseConstraintProto*>(
               &_InverseConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  friend void swap(InverseConstraintProto& a, InverseConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(InverseConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InverseConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  InverseConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<InverseConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const InverseConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const InverseConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.InverseConstraintProto";
  }
  protected:
  explicit InverseConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFDirectFieldNumber = 1,
    kFInverseFieldNumber = 2,
  };
  // repeated int32 f_direct = 1;
  int f_direct_size() const;
  private:
  int _internal_f_direct_size() const;
  public:
  void clear_f_direct();
  private:
  int32_t _internal_f_direct(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_f_direct() const;
  void _internal_add_f_direct(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_f_direct();
  public:
  int32_t f_direct(int index) const;
  void set_f_direct(int index, int32_t value);
  void add_f_direct(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      f_direct() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_f_direct();

  // repeated int32 f_inverse = 2;
  int f_inverse_size() const;
  private:
  int _internal_f_inverse_size() const;
  public:
  void clear_f_inverse();
  private:
  int32_t _internal_f_inverse(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_f_inverse() const;
  void _internal_add_f_inverse(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_f_inverse();
  public:
  int32_t f_inverse(int index) const;
  void set_f_inverse(int index, int32_t value);
  void add_f_inverse(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      f_inverse() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_f_inverse();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > f_direct_;
  mutable std::atomic<int> _f_direct_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > f_inverse_;
  mutable std::atomic<int> _f_inverse_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class AutomatonConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.AutomatonConstraintProto) */ {
 public:
  inline AutomatonConstraintProto() : AutomatonConstraintProto(nullptr) {}
  ~AutomatonConstraintProto() override;
  explicit constexpr AutomatonConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AutomatonConstraintProto(const AutomatonConstraintProto& from);
  AutomatonConstraintProto(AutomatonConstraintProto&& from) noexcept
    : AutomatonConstraintProto() {
    *this = ::std::move(from);
  }

  inline AutomatonConstraintProto& operator=(const AutomatonConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline AutomatonConstraintProto& operator=(AutomatonConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AutomatonConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const AutomatonConstraintProto* internal_default_instance() {
    return reinterpret_cast<const AutomatonConstraintProto*>(
               &_AutomatonConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  friend void swap(AutomatonConstraintProto& a, AutomatonConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(AutomatonConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AutomatonConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  AutomatonConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<AutomatonConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AutomatonConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const AutomatonConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.AutomatonConstraintProto";
  }
  protected:
  explicit AutomatonConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kFinalStatesFieldNumber = 3,
    kTransitionTailFieldNumber = 4,
    kTransitionHeadFieldNumber = 5,
    kTransitionLabelFieldNumber = 6,
    kVarsFieldNumber = 7,
    kStartingStateFieldNumber = 2,
  };
  // repeated int64 final_states = 3;
  int final_states_size() const;
  private:
  int _internal_final_states_size() const;
  public:
  void clear_final_states();
  private:
  int64_t _internal_final_states(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_final_states() const;
  void _internal_add_final_states(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_final_states();
  public:
  int64_t final_states(int index) const;
  void set_final_states(int index, int64_t value);
  void add_final_states(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      final_states() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_final_states();

  // repeated int64 transition_tail = 4;
  int transition_tail_size() const;
  private:
  int _internal_transition_tail_size() const;
  public:
  void clear_transition_tail();
  private:
  int64_t _internal_transition_tail(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_transition_tail() const;
  void _internal_add_transition_tail(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_transition_tail();
  public:
  int64_t transition_tail(int index) const;
  void set_transition_tail(int index, int64_t value);
  void add_transition_tail(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      transition_tail() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_transition_tail();

  // repeated int64 transition_head = 5;
  int transition_head_size() const;
  private:
  int _internal_transition_head_size() const;
  public:
  void clear_transition_head();
  private:
  int64_t _internal_transition_head(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_transition_head() const;
  void _internal_add_transition_head(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_transition_head();
  public:
  int64_t transition_head(int index) const;
  void set_transition_head(int index, int64_t value);
  void add_transition_head(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      transition_head() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_transition_head();

  // repeated int64 transition_label = 6;
  int transition_label_size() const;
  private:
  int _internal_transition_label_size() const;
  public:
  void clear_transition_label();
  private:
  int64_t _internal_transition_label(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_transition_label() const;
  void _internal_add_transition_label(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_transition_label();
  public:
  int64_t transition_label(int index) const;
  void set_transition_label(int index, int64_t value);
  void add_transition_label(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      transition_label() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_transition_label();

  // repeated int32 vars = 7;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // int64 starting_state = 2;
  void clear_starting_state();
  int64_t starting_state() const;
  void set_starting_state(int64_t value);
  private:
  int64_t _internal_starting_state() const;
  void _internal_set_starting_state(int64_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > final_states_;
  mutable std::atomic<int> _final_states_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > transition_tail_;
  mutable std::atomic<int> _transition_tail_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > transition_head_;
  mutable std::atomic<int> _transition_head_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > transition_label_;
  mutable std::atomic<int> _transition_label_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  int64_t starting_state_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class ListOfVariablesProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.ListOfVariablesProto) */ {
 public:
  inline ListOfVariablesProto() : ListOfVariablesProto(nullptr) {}
  ~ListOfVariablesProto() override;
  explicit constexpr ListOfVariablesProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ListOfVariablesProto(const ListOfVariablesProto& from);
  ListOfVariablesProto(ListOfVariablesProto&& from) noexcept
    : ListOfVariablesProto() {
    *this = ::std::move(from);
  }

  inline ListOfVariablesProto& operator=(const ListOfVariablesProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ListOfVariablesProto& operator=(ListOfVariablesProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ListOfVariablesProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const ListOfVariablesProto* internal_default_instance() {
    return reinterpret_cast<const ListOfVariablesProto*>(
               &_ListOfVariablesProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  friend void swap(ListOfVariablesProto& a, ListOfVariablesProto& b) {
    a.Swap(&b);
  }
  inline void Swap(ListOfVariablesProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ListOfVariablesProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ListOfVariablesProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ListOfVariablesProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ListOfVariablesProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ListOfVariablesProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ListOfVariablesProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.ListOfVariablesProto";
  }
  protected:
  explicit ListOfVariablesProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVarsFieldNumber = 1,
  };
  // repeated int32 vars = 1;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // @@protoc_insertion_point(class_scope:operations_research.sat.ListOfVariablesProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class ConstraintProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.ConstraintProto) */ {
 public:
  inline ConstraintProto() : ConstraintProto(nullptr) {}
  ~ConstraintProto() override;
  explicit constexpr ConstraintProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConstraintProto(const ConstraintProto& from);
  ConstraintProto(ConstraintProto&& from) noexcept
    : ConstraintProto() {
    *this = ::std::move(from);
  }

  inline ConstraintProto& operator=(const ConstraintProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConstraintProto& operator=(ConstraintProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ConstraintProto& default_instance() {
    return *internal_default_instance();
  }
  enum ConstraintCase {
    kBoolOr = 3,
    kBoolAnd = 4,
    kAtMostOne = 26,
    kExactlyOne = 29,
    kBoolXor = 5,
    kIntDiv = 7,
    kIntMod = 8,
    kIntProd = 11,
    kLinMax = 27,
    kLinear = 12,
    kAllDiff = 13,
    kElement = 14,
    kCircuit = 15,
    kRoutes = 23,
    kTable = 16,
    kAutomaton = 17,
    kInverse = 18,
    kReservoir = 24,
    kInterval = 19,
    kNoOverlap = 20,
    kNoOverlap2D = 21,
    kCumulative = 22,
    kDummyConstraint = 30,
    CONSTRAINT_NOT_SET = 0,
  };

  static inline const ConstraintProto* internal_default_instance() {
    return reinterpret_cast<const ConstraintProto*>(
               &_ConstraintProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  friend void swap(ConstraintProto& a, ConstraintProto& b) {
    a.Swap(&b);
  }
  inline void Swap(ConstraintProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConstraintProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  ConstraintProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<ConstraintProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ConstraintProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ConstraintProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.ConstraintProto";
  }
  protected:
  explicit ConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kEnforcementLiteralFieldNumber = 2,
    kNameFieldNumber = 1,
    kBoolOrFieldNumber = 3,
    kBoolAndFieldNumber = 4,
    kAtMostOneFieldNumber = 26,
    kExactlyOneFieldNumber = 29,
    kBoolXorFieldNumber = 5,
    kIntDivFieldNumber = 7,
    kIntModFieldNumber = 8,
    kIntProdFieldNumber = 11,
    kLinMaxFieldNumber = 27,
    kLinearFieldNumber = 12,
    kAllDiffFieldNumber = 13,
    kElementFieldNumber = 14,
    kCircuitFieldNumber = 15,
    kRoutesFieldNumber = 23,
    kTableFieldNumber = 16,
    kAutomatonFieldNumber = 17,
    kInverseFieldNumber = 18,
    kReservoirFieldNumber = 24,
    kIntervalFieldNumber = 19,
    kNoOverlapFieldNumber = 20,
    kNoOverlap2DFieldNumber = 21,
    kCumulativeFieldNumber = 22,
    kDummyConstraintFieldNumber = 30,
  };
  // repeated int32 enforcement_literal = 2;
  int enforcement_literal_size() const;
  private:
  int _internal_enforcement_literal_size() const;
  public:
  void clear_enforcement_literal();
  private:
  int32_t _internal_enforcement_literal(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_enforcement_literal() const;
  void _internal_add_enforcement_literal(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_enforcement_literal();
  public:
  int32_t enforcement_literal(int index) const;
  void set_enforcement_literal(int index, int32_t value);
  void add_enforcement_literal(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      enforcement_literal() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_enforcement_literal();

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .operations_research.sat.BoolArgumentProto bool_or = 3;
  bool has_bool_or() const;
  private:
  bool _internal_has_bool_or() const;
  public:
  void clear_bool_or();
  const ::operations_research::sat::BoolArgumentProto& bool_or() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::operations_research::sat::BoolArgumentProto& _internal_bool_or() const;
  ::operations_research::sat::BoolArgumentProto* _internal_mutable_bool_or();
  public:
  void unsafe_arena_set_allocated_bool_or(
      ::operations_research::sat::BoolArgumentProto* bool_or);
  ::operations_research::sat::BoolArgumentProto* unsafe_arena_release_bool_or();

  // .operations_research.sat.BoolArgumentProto bool_and = 4;
  bool has_bool_and() const;
  private:
  bool _internal_has_bool_and() const;
  public:
  void clear_bool_and();
  const ::operations_research::sat::BoolArgumentProto& bool_and() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::operations_research::sat::BoolArgumentProto& _internal_bool_and() const;
  ::operations_research::sat::BoolArgumentProto* _internal_mutable_bool_and();
  public:
  void unsafe_arena_set_allocated_bool_and(
      ::operations_research::sat::BoolArgumentProto* bool_and);
  ::operations_research::sat::BoolArgumentProto* unsafe_arena_release_bool_and();

  // .operations_research.sat.BoolArgumentProto at_most_one = 26;
  bool has_at_most_one() const;
  private:
  bool _internal_has_at_most_one() const;
  public:
  void clear_at_most_one();
  const ::operations_research::sat::BoolArgumentProto& at_most_one() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::operations_research::sat::BoolArgumentProto& _internal_at_most_one() const;
  ::operations_research::sat::BoolArgumentProto* _internal_mutable_at_most_one();
  public:
  void unsafe_arena_set_allocated_at_most_one(
      ::operations_research::sat::BoolArgumentProto* at_most_one);
  ::operations_research::sat::BoolArgumentProto* unsafe_arena_release_at_most_one();

  // .operations_research.sat.BoolArgumentProto exactly_one = 29;
  bool has_exactly_one() const;
  private:
  bool _internal_has_exactly_one() const;
  public:
  void clear_exactly_one();
  const ::operations_research::sat::BoolArgumentProto& exactly_one() const;
  PROTOBUF_NODISCARD ::operations_research::sat::BoolArgumentProto* release_exactly_one();
  ::operations_research::sat::BoolArgumentProto* mutable_exactly_one();
  void set_allocated_exactly_one(::operations_research::sat::BoolArgumentProto* exactly_one);
  private:
  const ::operations_research::sat::BoolArgumentProto& _internal_exactly_one() const;
  ::operations_research::sat::BoolArgumentProto* _internal_mutable_exactly_one();
  public:
  void unsafe_arena_set_allocated_exactly_one(
      ::operations_research::sat::BoolArgumentProto* exactly_one);
  ::operations_research::sat::BoolArgumentProto* unsafe_arena_release_exactly_one();

  // .operations_research.sat.BoolArgumentProto bool_xor = 5;
  bool has_bool_xor() const;
  private:
  bool _internal_has_bool_xor() const;
  public:
  void clear_bool_xor();
  const ::operations_research::sat::BoolArgumentProto& bool_xor() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::operations_research::sat::BoolArgumentProto& _internal_bool_xor() const;
  ::operations_research::sat::BoolArgumentProto* _internal_mutable_bool_xor();
  public:
  void unsafe_arena_set_allocated_bool_xor(
      ::operations_research::sat::BoolArgumentProto* bool_xor);
  ::operations_research::sat::BoolArgumentProto* unsafe_arena_release_bool_xor();

  // .operations_research.sat.LinearArgumentProto int_div = 7;
  bool has_int_div() const;
  private:
  bool _internal_has_int_div() const;
  public:
  void clear_int_div();
  const ::operations_research::sat::LinearArgumentProto& int_div() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearArgumentProto* release_int_div();
  ::operations_research::sat::LinearArgumentProto* mutable_int_div();
  void set_allocated_int_div(::operations_research::sat::LinearArgumentProto* int_div);
  private:
  const ::operations_research::sat::LinearArgumentProto& _internal_int_div() const;
  ::operations_research::sat::LinearArgumentProto* _internal_mutable_int_div();
  public:
  void unsafe_arena_set_allocated_int_div(
      ::operations_research::sat::LinearArgumentProto* int_div);
  ::operations_research::sat::LinearArgumentProto* unsafe_arena_release_int_div();

  // .operations_research.sat.LinearArgumentProto int_mod = 8;
  bool has_int_mod() const;
  private:
  bool _internal_has_int_mod() const;
  public:
  void clear_int_mod();
  const ::operations_research::sat::LinearArgumentProto& int_mod() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearArgumentProto* release_int_mod();
  ::operations_research::sat::LinearArgumentProto* mutable_int_mod();
  void set_allocated_int_mod(::operations_research::sat::LinearArgumentProto* int_mod);
  private:
  const ::operations_research::sat::LinearArgumentProto& _internal_int_mod() const;
  ::operations_research::sat::LinearArgumentProto* _internal_mutable_int_mod();
  public:
  void unsafe_arena_set_allocated_int_mod(
      ::operations_research::sat::LinearArgumentProto* int_mod);
  ::operations_research::sat::LinearArgumentProto* unsafe_arena_release_int_mod();

  // .operations_research.sat.LinearArgumentProto int_prod = 11;
  bool has_int_prod() const;
  private:
  bool _internal_has_int_prod() const;
  public:
  void clear_int_prod();
  const ::operations_research::sat::LinearArgumentProto& int_prod() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearArgumentProto* release_int_prod();
  ::operations_research::sat::LinearArgumentProto* mutable_int_prod();
  void set_allocated_int_prod(::operations_research::sat::LinearArgumentProto* int_prod);
  private:
  const ::operations_research::sat::LinearArgumentProto& _internal_int_prod() const;
  ::operations_research::sat::LinearArgumentProto* _internal_mutable_int_prod();
  public:
  void unsafe_arena_set_allocated_int_prod(
      ::operations_research::sat::LinearArgumentProto* int_prod);
  ::operations_research::sat::LinearArgumentProto* unsafe_arena_release_int_prod();

  // .operations_research.sat.LinearArgumentProto lin_max = 27;
  bool has_lin_max() const;
  private:
  bool _internal_has_lin_max() const;
  public:
  void clear_lin_max();
  const ::operations_research::sat::LinearArgumentProto& lin_max() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearArgumentProto* release_lin_max();
  ::operations_research::sat::LinearArgumentProto* mutable_lin_max();
  void set_allocated_lin_max(::operations_research::sat::LinearArgumentProto* lin_max);
  private:
  const ::operations_research::sat::LinearArgumentProto& _internal_lin_max() const;
  ::operations_research::sat::LinearArgumentProto* _internal_mutable_lin_max();
  public:
  void unsafe_arena_set_allocated_lin_max(
      ::operations_research::sat::LinearArgumentProto* lin_max);
  ::operations_research::sat::LinearArgumentProto* unsafe_arena_release_lin_max();

  // .operations_research.sat.LinearConstraintProto linear = 12;
  bool has_linear() const;
  private:
  bool _internal_has_linear() const;
  public:
  void clear_linear();
  const ::operations_research::sat::LinearConstraintProto& linear() const;
  PROTOBUF_NODISCARD ::operations_research::sat::LinearConstraintProto* release_linear();
  ::operations_research::sat::LinearConstraintProto* mutable_linear();
  void set_allocated_linear(::operations_research::sat::LinearConstraintProto* linear);
  private:
  const ::operations_research::sat::LinearConstraintProto& _internal_linear() const;
  ::operations_research::sat::LinearConstraintProto* _internal_mutable_linear();
  public:
  void unsafe_arena_set_allocated_linear(
      ::operations_research::sat::LinearConstraintProto* linear);
  ::operations_research::sat::LinearConstraintProto* unsafe_arena_release_linear();

  // .operations_research.sat.AllDifferentConstraintProto all_diff = 13;
  bool has_all_diff() const;
  private:
  bool _internal_has_all_diff() const;
  public:
  void clear_all_diff();
  const ::operations_research::sat::AllDifferentConstraintProto& all_diff() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::operations_research::sat::AllDifferentConstraintProto& _internal_all_diff() const;
  ::operations_research::sat::AllDifferentConstraintProto* _internal_mutable_all_diff();
  public:
  void unsafe_arena_set_allocated_all_diff(
      ::operations_research::sat::AllDifferentConstraintProto* all_diff);
  ::operations_research::sat::AllDifferentConstraintProto* unsafe_arena_release_all_diff();

  // .operations_research.sat.ElementConstraintProto element = 14;
  bool has_element() const;
  private:
  bool _internal_has_element() const;
  public:
  void clear_element();
  const ::operations_research::sat::ElementConstraintProto& element() const;
  PROTOBUF_NODISCARD ::operations_research::sat::ElementConstraintProto* release_element();
  ::operations_research::sat::ElementConstraintProto* mutable_element();
  void set_allocated_element(::operations_research::sat::ElementConstraintProto* element);
  private:
  const ::operations_research::sat::ElementConstraintProto& _internal_element() const;
  ::operations_research::sat::ElementConstraintProto* _internal_mutable_element();
  public:
  void unsafe_arena_set_allocated_element(
      ::operations_research::sat::ElementConstraintProto* element);
  ::operations_research::sat::ElementConstraintProto* unsafe_arena_release_element();

  // .operations_research.sat.CircuitConstraintProto circuit = 15;
  bool has_circuit() const;
  private:
  bool _internal_has_circuit() const;
  public:
  void clear_circuit();
  const ::operations_research::sat::CircuitConstraintProto& circuit() const;
  PROTOBUF_NODISCARD ::operations_research::sat::CircuitConstraintProto* release_circuit();
  ::operations_research::sat::CircuitConstraintProto* mutable_circuit();
  void set_allocated_circuit(::operations_research::sat::CircuitConstraintProto* circuit);
  private:
  const ::operations_research::sat::CircuitConstraintProto& _internal_circuit() const;
  ::operations_research::sat::CircuitConstraintProto* _internal_mutable_circuit();
  public:
  void unsafe_arena_set_allocated_circuit(
      ::operations_research::sat::CircuitConstraintProto* circuit);
  ::operations_research::sat::CircuitConstraintProto* unsafe_arena_release_circuit();

  // .operations_research.sat.RoutesConstraintProto routes = 23;
  bool has_routes() const;
  private:
  bool _internal_has_routes() const;
  public:
  void clear_routes();
  const ::operations_research::sat::RoutesConstraintProto& routes() const;
  PROTOBUF_NODISCARD ::operations_research::sat::RoutesConstraintProto* release_routes();
  ::operations_research::sat::RoutesConstraintProto* mutable_routes();
  void set_allocated_routes(::operations_research::sat::RoutesConstraintProto* routes);
  private:
  const ::operations_research::sat::RoutesConstraintProto& _internal_routes() const;
  ::operations_research::sat::RoutesConstraintProto* _internal_mutable_routes();
  public:
  void unsafe_arena_set_allocated_routes(
      ::operations_research::sat::RoutesConstraintProto* routes);
  ::operations_research::sat::RoutesConstraintProto* unsafe_arena_release_routes();

  // .operations_research.sat.TableConstraintProto table = 16;
  bool has_table() const;
  private:
  bool _internal_has_table() const;
  public:
  void clear_table();
  const ::operations_research::sat::TableConstraintProto& table() const;
  PROTOBUF_NODISCARD ::operations_research::sat::TableConstraintProto* release_table();
  ::operations_research::sat::TableConstraintProto* mutable_table();
  void set_allocated_table(::operations_research::sat::TableConstraintProto* table);
  private:
  const ::operations_research::sat::TableConstraintProto& _internal_table() const;
  ::operations_research::sat::TableConstraintProto* _internal_mutable_table();
  public:
  void unsafe_arena_set_allocated_table(
      ::operations_research::sat::TableConstraintProto* table);
  ::operations_research::sat::TableConstraintProto* unsafe_arena_release_table();

  // .operations_research.sat.AutomatonConstraintProto automaton = 17;
  bool has_automaton() const;
  private:
  bool _internal_has_automaton() const;
  public:
  void clear_automaton();
  const ::operations_research::sat::AutomatonConstraintProto& automaton() const;
  PROTOBUF_NODISCARD ::operations_research::sat::AutomatonConstraintProto* release_automaton();
  ::operations_research::sat::AutomatonConstraintProto* mutable_automaton();
  void set_allocated_automaton(::operations_research::sat::AutomatonConstraintProto* automaton);
  private:
  const ::operations_research::sat::AutomatonConstraintProto& _internal_automaton() const;
  ::operations_research::sat::AutomatonConstraintProto* _internal_mutable_automaton();
  public:
  void unsafe_arena_set_allocated_automaton(
      ::operations_research::sat::AutomatonConstraintProto* automaton);
  ::operations_research::sat::AutomatonConstraintProto* unsafe_arena_release_automaton();

  // .operations_research.sat.InverseConstraintProto inverse = 18;
  bool has_inverse() const;
  private:
  bool _internal_has_inverse() const;
  public:
  void clear_inverse();
  const ::operations_research::sat::InverseConstraintProto& inverse() const;
  PROTOBUF_NODISCARD ::operations_research::sat::InverseConstraintProto* release_inverse();
  ::operations_research::sat::InverseConstraintProto* mutable_inverse();
  void set_allocated_inverse(::operations_research::sat::InverseConstraintProto* inverse);
  private:
  const ::operations_research::sat::InverseConstraintProto& _internal_inverse() const;
  ::operations_research::sat::InverseConstraintProto* _internal_mutable_inverse();
  public:
  void unsafe_arena_set_allocated_inverse(
      ::operations_research::sat::InverseConstraintProto* inverse);
  ::operations_research::sat::InverseConstraintProto* unsafe_arena_release_inverse();

  // .operations_research.sat.ReservoirConstraintProto reservoir = 24;
  bool has_reservoir() const;
  private:
  bool _internal_has_reservoir() const;
  public:
  void clear_reservoir();
  const ::operations_research::sat::ReservoirConstraintProto& reservoir() const;
  PROTOBUF_NODISCARD ::operations_research::sat::ReservoirConstraintProto* release_reservoir();
  ::operations_research::sat::ReservoirConstraintProto* mutable_reservoir();
  void set_allocated_reservoir(::operations_research::sat::ReservoirConstraintProto* reservoir);
  private:
  const ::operations_research::sat::ReservoirConstraintProto& _internal_reservoir() const;
  ::operations_research::sat::ReservoirConstraintProto* _internal_mutable_reservoir();
  public:
  void unsafe_arena_set_allocated_reservoir(
      ::operations_research::sat::ReservoirConstraintProto* reservoir);
  ::operations_research::sat::ReservoirConstraintProto* unsafe_arena_release_reservoir();

  // .operations_research.sat.IntervalConstraintProto interval = 19;
  bool has_interval() const;
  private:
  bool _internal_has_interval() const;
  public:
  void clear_interval();
  const ::operations_research::sat::IntervalConstraintProto& interval() const;
  PROTOBUF_NODISCARD ::operations_research::sat::IntervalConstraintProto* release_interval();
  ::operations_research::sat::IntervalConstraintProto* mutable_interval();
  void set_allocated_interval(::operations_research::sat::IntervalConstraintProto* interval);
  private:
  const ::operations_research::sat::IntervalConstraintProto& _internal_interval() const;
  ::operations_research::sat::IntervalConstraintProto* _internal_mutable_interval();
  public:
  void unsafe_arena_set_allocated_interval(
      ::operations_research::sat::IntervalConstraintProto* interval);
  ::operations_research::sat::IntervalConstraintProto* unsafe_arena_release_interval();

  // .operations_research.sat.NoOverlapConstraintProto no_overlap = 20;
  bool has_no_overlap() const;
  private:
  bool _internal_has_no_overlap() const;
  public:
  void clear_no_overlap();
  const ::operations_research::sat::NoOverlapConstraintProto& no_overlap() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::operations_research::sat::NoOverlapConstraintProto& _internal_no_overlap() const;
  ::operations_research::sat::NoOverlapConstraintProto* _internal_mutable_no_overlap();
  public:
  void unsafe_arena_set_allocated_no_overlap(
      ::operations_research::sat::NoOverlapConstraintProto* no_overlap);
  ::operations_research::sat::NoOverlapConstraintProto* unsafe_arena_release_no_overlap();

  // .operations_research.sat.NoOverlap2DConstraintProto no_overlap_2d = 21;
  bool has_no_overlap_2d() const;
  private:
  bool _internal_has_no_overlap_2d() const;
  public:
  void clear_no_overlap_2d();
  const ::operations_research::sat::NoOverlap2DConstraintProto& no_overlap_2d() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::operations_research::sat::NoOverlap2DConstraintProto& _internal_no_overlap_2d() const;
  ::operations_research::sat::NoOverlap2DConstraintProto* _internal_mutable_no_overlap_2d();
  public:
  void unsafe_arena_set_allocated_no_overlap_2d(
      ::operations_research::sat::NoOverlap2DConstraintProto* no_overlap_2d);
  ::operations_research::sat::NoOverlap2DConstraintProto* unsafe_arena_release_no_overlap_2d();

  // .operations_research.sat.CumulativeConstraintProto cumulative = 22;
  bool has_cumulative() const;
  private:
  bool _internal_has_cumulative() const;
  public:
  void clear_cumulative();
  const ::operations_research::sat::CumulativeConstraintProto& cumulative() const;
  PROTOBUF_NODISCARD ::operations_research::sat::CumulativeConstraintProto* release_cumulative();
  ::operations_research::sat::CumulativeConstraintProto* mutable_cumulative();
  void set_allocated_cumulative(::operations_research::sat::CumulativeConstraintProto* cumulative);
  private:
  const ::operations_research::sat::CumulativeConstraintProto& _internal_cumulative() const;
  ::operations_research::sat::CumulativeConstraintProto* _internal_mutable_cumulative();
  public:
  void unsafe_arena_set_allocated_cumulative(
      ::operations_research::sat::CumulativeConstraintProto* cumulative);
  ::operations_research::sat::CumulativeConstraintProto* unsafe_arena_release_cumulative();

  // .operations_research.sat.ListOfVariablesProto dummy_constraint = 30;
  bool has_dummy_constraint() const;
  private:
  bool _internal_has_dummy_constraint() const;
  public:
  void clear_dummy_constraint();
  const ::operations_research::sat::ListOfVariablesProto& dummy_constraint() const;
  PROTOBUF_NODISCARD ::operations_research::sat::ListOfVariablesProto* release_dummy_constraint();
  ::operations_research::sat::ListOfVariablesProto* mutable_dummy_constraint();
  void set_allocated_dummy_constraint(::operations_research::sat::ListOfVariablesProto* dummy_constraint);
  private:
  const ::operations_research::sat::ListOfVariablesProto& _internal_dummy_constraint() const;
  ::operations_research::sat::ListOfVariablesProto* _internal_mutable_dummy_constraint();
  public:
  void unsafe_arena_set_allocated_dummy_constraint(
      ::operations_research::sat::ListOfVariablesProto* dummy_constraint);
  ::operations_research::sat::ListOfVariablesProto* unsafe_arena_release_dummy_constraint();

  void clear_constraint();
  ConstraintCase constraint_case() const;
  // @@protoc_insertion_point(class_scope:operations_research.sat.ConstraintProto)
 private:
  class _Internal;
  void set_has_bool_or();
  void set_has_bool_and();
  void set_has_at_most_one();
  void set_has_exactly_one();
  void set_has_bool_xor();
  void set_has_int_div();
  void set_has_int_mod();
  void set_has_int_prod();
  void set_has_lin_max();
  void set_has_linear();
  void set_has_all_diff();
  void set_has_element();
  void set_has_circuit();
  void set_has_routes();
  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();
  void set_has_dummy_constraint();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > enforcement_literal_;
  mutable std::atomic<int> _enforcement_literal_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  union ConstraintUnion {
    constexpr ConstraintUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::operations_research::sat::BoolArgumentProto* bool_or_;
    ::operations_research::sat::BoolArgumentProto* bool_and_;
    ::operations_research::sat::BoolArgumentProto* at_most_one_;
    ::operations_research::sat::BoolArgumentProto* exactly_one_;
    ::operations_research::sat::BoolArgumentProto* bool_xor_;
    ::operations_research::sat::LinearArgumentProto* int_div_;
    ::operations_research::sat::LinearArgumentProto* int_mod_;
    ::operations_research::sat::LinearArgumentProto* int_prod_;
    ::operations_research::sat::LinearArgumentProto* lin_max_;
    ::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::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_;
    ::operations_research::sat::ListOfVariablesProto* dummy_constraint_;
  } constraint_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  uint32_t _oneof_case_[1];

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

class CpObjectiveProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CpObjectiveProto) */ {
 public:
  inline CpObjectiveProto() : CpObjectiveProto(nullptr) {}
  ~CpObjectiveProto() override;
  explicit constexpr CpObjectiveProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CpObjectiveProto(const CpObjectiveProto& from);
  CpObjectiveProto(CpObjectiveProto&& from) noexcept
    : CpObjectiveProto() {
    *this = ::std::move(from);
  }

  inline CpObjectiveProto& operator=(const CpObjectiveProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CpObjectiveProto& operator=(CpObjectiveProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CpObjectiveProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const CpObjectiveProto* internal_default_instance() {
    return reinterpret_cast<const CpObjectiveProto*>(
               &_CpObjectiveProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  friend void swap(CpObjectiveProto& a, CpObjectiveProto& b) {
    a.Swap(&b);
  }
  inline void Swap(CpObjectiveProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CpObjectiveProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CpObjectiveProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CpObjectiveProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CpObjectiveProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CpObjectiveProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.CpObjectiveProto";
  }
  protected:
  explicit CpObjectiveProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVarsFieldNumber = 1,
    kCoeffsFieldNumber = 4,
    kDomainFieldNumber = 5,
    kOffsetFieldNumber = 2,
    kScalingFactorFieldNumber = 3,
    kIntegerOffsetFieldNumber = 7,
    kIntegerScalingFactorFieldNumber = 8,
    kScalingWasExactFieldNumber = 6,
  };
  // repeated int32 vars = 1;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // repeated int64 coeffs = 4;
  int coeffs_size() const;
  private:
  int _internal_coeffs_size() const;
  public:
  void clear_coeffs();
  private:
  int64_t _internal_coeffs(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_coeffs() const;
  void _internal_add_coeffs(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_coeffs();
  public:
  int64_t coeffs(int index) const;
  void set_coeffs(int index, int64_t value);
  void add_coeffs(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      coeffs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_coeffs();

  // repeated int64 domain = 5;
  int domain_size() const;
  private:
  int _internal_domain_size() const;
  public:
  void clear_domain();
  private:
  int64_t _internal_domain(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_domain() const;
  void _internal_add_domain(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_domain();
  public:
  int64_t domain(int index) const;
  void set_domain(int index, int64_t value);
  void add_domain(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      domain() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_domain();

  // double offset = 2;
  void clear_offset();
  double offset() const;
  void set_offset(double value);
  private:
  double _internal_offset() const;
  void _internal_set_offset(double value);
  public:

  // double scaling_factor = 3;
  void clear_scaling_factor();
  double scaling_factor() const;
  void set_scaling_factor(double value);
  private:
  double _internal_scaling_factor() const;
  void _internal_set_scaling_factor(double value);
  public:

  // int64 integer_offset = 7;
  void clear_integer_offset();
  int64_t integer_offset() const;
  void set_integer_offset(int64_t value);
  private:
  int64_t _internal_integer_offset() const;
  void _internal_set_integer_offset(int64_t value);
  public:

  // int64 integer_scaling_factor = 8;
  void clear_integer_scaling_factor();
  int64_t integer_scaling_factor() const;
  void set_integer_scaling_factor(int64_t value);
  private:
  int64_t _internal_integer_scaling_factor() const;
  void _internal_set_integer_scaling_factor(int64_t value);
  public:

  // bool scaling_was_exact = 6;
  void clear_scaling_was_exact();
  bool scaling_was_exact() const;
  void set_scaling_was_exact(bool value);
  private:
  bool _internal_scaling_was_exact() const;
  void _internal_set_scaling_was_exact(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > coeffs_;
  mutable std::atomic<int> _coeffs_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > domain_;
  mutable std::atomic<int> _domain_cached_byte_size_;
  double offset_;
  double scaling_factor_;
  int64_t integer_offset_;
  int64_t integer_scaling_factor_;
  bool scaling_was_exact_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class FloatObjectiveProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.FloatObjectiveProto) */ {
 public:
  inline FloatObjectiveProto() : FloatObjectiveProto(nullptr) {}
  ~FloatObjectiveProto() override;
  explicit constexpr FloatObjectiveProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FloatObjectiveProto(const FloatObjectiveProto& from);
  FloatObjectiveProto(FloatObjectiveProto&& from) noexcept
    : FloatObjectiveProto() {
    *this = ::std::move(from);
  }

  inline FloatObjectiveProto& operator=(const FloatObjectiveProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline FloatObjectiveProto& operator=(FloatObjectiveProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FloatObjectiveProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const FloatObjectiveProto* internal_default_instance() {
    return reinterpret_cast<const FloatObjectiveProto*>(
               &_FloatObjectiveProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  friend void swap(FloatObjectiveProto& a, FloatObjectiveProto& b) {
    a.Swap(&b);
  }
  inline void Swap(FloatObjectiveProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FloatObjectiveProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  FloatObjectiveProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<FloatObjectiveProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FloatObjectiveProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FloatObjectiveProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FloatObjectiveProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.FloatObjectiveProto";
  }
  protected:
  explicit FloatObjectiveProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVarsFieldNumber = 1,
    kCoeffsFieldNumber = 2,
    kOffsetFieldNumber = 3,
    kMaximizeFieldNumber = 4,
  };
  // repeated int32 vars = 1;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // repeated double coeffs = 2;
  int coeffs_size() const;
  private:
  int _internal_coeffs_size() const;
  public:
  void clear_coeffs();
  private:
  double _internal_coeffs(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_coeffs() const;
  void _internal_add_coeffs(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_coeffs();
  public:
  double coeffs(int index) const;
  void set_coeffs(int index, double value);
  void add_coeffs(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      coeffs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_coeffs();

  // double offset = 3;
  void clear_offset();
  double offset() const;
  void set_offset(double value);
  private:
  double _internal_offset() const;
  void _internal_set_offset(double value);
  public:

  // bool maximize = 4;
  void clear_maximize();
  bool maximize() const;
  void set_maximize(bool value);
  private:
  bool _internal_maximize() const;
  void _internal_set_maximize(bool value);
  public:

  // @@protoc_insertion_point(class_scope:operations_research.sat.FloatObjectiveProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > coeffs_;
  double offset_;
  bool maximize_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class DecisionStrategyProto_AffineTransformation final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.DecisionStrategyProto.AffineTransformation) */ {
 public:
  inline DecisionStrategyProto_AffineTransformation() : DecisionStrategyProto_AffineTransformation(nullptr) {}
  ~DecisionStrategyProto_AffineTransformation() override;
  explicit constexpr DecisionStrategyProto_AffineTransformation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DecisionStrategyProto_AffineTransformation(const DecisionStrategyProto_AffineTransformation& from);
  DecisionStrategyProto_AffineTransformation(DecisionStrategyProto_AffineTransformation&& from) noexcept
    : DecisionStrategyProto_AffineTransformation() {
    *this = ::std::move(from);
  }

  inline DecisionStrategyProto_AffineTransformation& operator=(const DecisionStrategyProto_AffineTransformation& from) {
    CopyFrom(from);
    return *this;
  }
  inline DecisionStrategyProto_AffineTransformation& operator=(DecisionStrategyProto_AffineTransformation&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DecisionStrategyProto_AffineTransformation& default_instance() {
    return *internal_default_instance();
  }
  static inline const DecisionStrategyProto_AffineTransformation* internal_default_instance() {
    return reinterpret_cast<const DecisionStrategyProto_AffineTransformation*>(
               &_DecisionStrategyProto_AffineTransformation_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  friend void swap(DecisionStrategyProto_AffineTransformation& a, DecisionStrategyProto_AffineTransformation& b) {
    a.Swap(&b);
  }
  inline void Swap(DecisionStrategyProto_AffineTransformation* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DecisionStrategyProto_AffineTransformation* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DecisionStrategyProto_AffineTransformation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DecisionStrategyProto_AffineTransformation>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DecisionStrategyProto_AffineTransformation& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DecisionStrategyProto_AffineTransformation& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.DecisionStrategyProto.AffineTransformation";
  }
  protected:
  explicit DecisionStrategyProto_AffineTransformation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kOffsetFieldNumber = 2,
    kPositiveCoeffFieldNumber = 3,
    kIndexFieldNumber = 1,
  };
  // int64 offset = 2;
  void clear_offset();
  int64_t offset() const;
  void set_offset(int64_t value);
  private:
  int64_t _internal_offset() const;
  void _internal_set_offset(int64_t value);
  public:

  // int64 positive_coeff = 3;
  void clear_positive_coeff();
  int64_t positive_coeff() const;
  void set_positive_coeff(int64_t value);
  private:
  int64_t _internal_positive_coeff() const;
  void _internal_set_positive_coeff(int64_t value);
  public:

  // int32 index = 1;
  void clear_index();
  int32_t index() const;
  void set_index(int32_t value);
  private:
  int32_t _internal_index() const;
  void _internal_set_index(int32_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int64_t offset_;
  int64_t positive_coeff_;
  int32_t index_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class DecisionStrategyProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.DecisionStrategyProto) */ {
 public:
  inline DecisionStrategyProto() : DecisionStrategyProto(nullptr) {}
  ~DecisionStrategyProto() override;
  explicit constexpr DecisionStrategyProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DecisionStrategyProto(const DecisionStrategyProto& from);
  DecisionStrategyProto(DecisionStrategyProto&& from) noexcept
    : DecisionStrategyProto() {
    *this = ::std::move(from);
  }

  inline DecisionStrategyProto& operator=(const DecisionStrategyProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DecisionStrategyProto& operator=(DecisionStrategyProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DecisionStrategyProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const DecisionStrategyProto* internal_default_instance() {
    return reinterpret_cast<const DecisionStrategyProto*>(
               &_DecisionStrategyProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  friend void swap(DecisionStrategyProto& a, DecisionStrategyProto& b) {
    a.Swap(&b);
  }
  inline void Swap(DecisionStrategyProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DecisionStrategyProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DecisionStrategyProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DecisionStrategyProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DecisionStrategyProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DecisionStrategyProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.DecisionStrategyProto";
  }
  protected:
  explicit DecisionStrategyProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

  typedef DecisionStrategyProto_AffineTransformation AffineTransformation;

  typedef DecisionStrategyProto_VariableSelectionStrategy VariableSelectionStrategy;
  static constexpr VariableSelectionStrategy CHOOSE_FIRST =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_FIRST;
  static constexpr VariableSelectionStrategy CHOOSE_LOWEST_MIN =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_LOWEST_MIN;
  static constexpr VariableSelectionStrategy CHOOSE_HIGHEST_MAX =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_HIGHEST_MAX;
  static constexpr VariableSelectionStrategy CHOOSE_MIN_DOMAIN_SIZE =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_MIN_DOMAIN_SIZE;
  static constexpr VariableSelectionStrategy CHOOSE_MAX_DOMAIN_SIZE =
    DecisionStrategyProto_VariableSelectionStrategy_CHOOSE_MAX_DOMAIN_SIZE;
  static inline bool VariableSelectionStrategy_IsValid(int value) {
    return DecisionStrategyProto_VariableSelectionStrategy_IsValid(value);
  }
  static constexpr VariableSelectionStrategy VariableSelectionStrategy_MIN =
    DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MIN;
  static constexpr VariableSelectionStrategy VariableSelectionStrategy_MAX =
    DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_MAX;
  static constexpr int VariableSelectionStrategy_ARRAYSIZE =
    DecisionStrategyProto_VariableSelectionStrategy_VariableSelectionStrategy_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  VariableSelectionStrategy_descriptor() {
    return DecisionStrategyProto_VariableSelectionStrategy_descriptor();
  }
  template<typename T>
  static inline const std::string& VariableSelectionStrategy_Name(T enum_t_value) {
    static_assert(::std::is_same<T, VariableSelectionStrategy>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function VariableSelectionStrategy_Name.");
    return DecisionStrategyProto_VariableSelectionStrategy_Name(enum_t_value);
  }
  static inline bool VariableSelectionStrategy_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      VariableSelectionStrategy* value) {
    return DecisionStrategyProto_VariableSelectionStrategy_Parse(name, value);
  }

  typedef DecisionStrategyProto_DomainReductionStrategy DomainReductionStrategy;
  static constexpr DomainReductionStrategy SELECT_MIN_VALUE =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_MIN_VALUE;
  static constexpr DomainReductionStrategy SELECT_MAX_VALUE =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_MAX_VALUE;
  static constexpr DomainReductionStrategy SELECT_LOWER_HALF =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_LOWER_HALF;
  static constexpr DomainReductionStrategy SELECT_UPPER_HALF =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_UPPER_HALF;
  static constexpr DomainReductionStrategy SELECT_MEDIAN_VALUE =
    DecisionStrategyProto_DomainReductionStrategy_SELECT_MEDIAN_VALUE;
  static inline bool DomainReductionStrategy_IsValid(int value) {
    return DecisionStrategyProto_DomainReductionStrategy_IsValid(value);
  }
  static constexpr DomainReductionStrategy DomainReductionStrategy_MIN =
    DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MIN;
  static constexpr DomainReductionStrategy DomainReductionStrategy_MAX =
    DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_MAX;
  static constexpr int DomainReductionStrategy_ARRAYSIZE =
    DecisionStrategyProto_DomainReductionStrategy_DomainReductionStrategy_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  DomainReductionStrategy_descriptor() {
    return DecisionStrategyProto_DomainReductionStrategy_descriptor();
  }
  template<typename T>
  static inline const std::string& DomainReductionStrategy_Name(T enum_t_value) {
    static_assert(::std::is_same<T, DomainReductionStrategy>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function DomainReductionStrategy_Name.");
    return DecisionStrategyProto_DomainReductionStrategy_Name(enum_t_value);
  }
  static inline bool DomainReductionStrategy_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      DomainReductionStrategy* value) {
    return DecisionStrategyProto_DomainReductionStrategy_Parse(name, value);
  }

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

  enum : int {
    kVariablesFieldNumber = 1,
    kTransformationsFieldNumber = 4,
    kVariableSelectionStrategyFieldNumber = 2,
    kDomainReductionStrategyFieldNumber = 3,
  };
  // repeated int32 variables = 1;
  int variables_size() const;
  private:
  int _internal_variables_size() const;
  public:
  void clear_variables();
  private:
  int32_t _internal_variables(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_variables() const;
  void _internal_add_variables(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_variables();
  public:
  int32_t variables(int index) const;
  void set_variables(int index, int32_t value);
  void add_variables(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      variables() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_variables();

  // repeated .operations_research.sat.DecisionStrategyProto.AffineTransformation transformations = 4;
  int transformations_size() const;
  private:
  int _internal_transformations_size() const;
  public:
  void clear_transformations();
  ::operations_research::sat::DecisionStrategyProto_AffineTransformation* mutable_transformations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto_AffineTransformation >*
      mutable_transformations();
  private:
  const ::operations_research::sat::DecisionStrategyProto_AffineTransformation& _internal_transformations(int index) const;
  ::operations_research::sat::DecisionStrategyProto_AffineTransformation* _internal_add_transformations();
  public:
  const ::operations_research::sat::DecisionStrategyProto_AffineTransformation& transformations(int index) const;
  ::operations_research::sat::DecisionStrategyProto_AffineTransformation* add_transformations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto_AffineTransformation >&
      transformations() const;

  // .operations_research.sat.DecisionStrategyProto.VariableSelectionStrategy variable_selection_strategy = 2;
  void clear_variable_selection_strategy();
  ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy variable_selection_strategy() const;
  void set_variable_selection_strategy(::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy value);
  private:
  ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy _internal_variable_selection_strategy() const;
  void _internal_set_variable_selection_strategy(::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy value);
  public:

  // .operations_research.sat.DecisionStrategyProto.DomainReductionStrategy domain_reduction_strategy = 3;
  void clear_domain_reduction_strategy();
  ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy domain_reduction_strategy() const;
  void set_domain_reduction_strategy(::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy value);
  private:
  ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy _internal_domain_reduction_strategy() const;
  void _internal_set_domain_reduction_strategy(::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > variables_;
  mutable std::atomic<int> _variables_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto_AffineTransformation > transformations_;
  int variable_selection_strategy_;
  int domain_reduction_strategy_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class PartialVariableAssignment final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.PartialVariableAssignment) */ {
 public:
  inline PartialVariableAssignment() : PartialVariableAssignment(nullptr) {}
  ~PartialVariableAssignment() override;
  explicit constexpr PartialVariableAssignment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  PartialVariableAssignment(const PartialVariableAssignment& from);
  PartialVariableAssignment(PartialVariableAssignment&& from) noexcept
    : PartialVariableAssignment() {
    *this = ::std::move(from);
  }

  inline PartialVariableAssignment& operator=(const PartialVariableAssignment& from) {
    CopyFrom(from);
    return *this;
  }
  inline PartialVariableAssignment& operator=(PartialVariableAssignment&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const PartialVariableAssignment& default_instance() {
    return *internal_default_instance();
  }
  static inline const PartialVariableAssignment* internal_default_instance() {
    return reinterpret_cast<const PartialVariableAssignment*>(
               &_PartialVariableAssignment_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  friend void swap(PartialVariableAssignment& a, PartialVariableAssignment& b) {
    a.Swap(&b);
  }
  inline void Swap(PartialVariableAssignment* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(PartialVariableAssignment* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  PartialVariableAssignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<PartialVariableAssignment>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const PartialVariableAssignment& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const PartialVariableAssignment& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.PartialVariableAssignment";
  }
  protected:
  explicit PartialVariableAssignment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVarsFieldNumber = 1,
    kValuesFieldNumber = 2,
  };
  // repeated int32 vars = 1;
  int vars_size() const;
  private:
  int _internal_vars_size() const;
  public:
  void clear_vars();
  private:
  int32_t _internal_vars(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_vars() const;
  void _internal_add_vars(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_vars();
  public:
  int32_t vars(int index) const;
  void set_vars(int index, int32_t value);
  void add_vars(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      vars() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_vars();

  // repeated int64 values = 2;
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  private:
  int64_t _internal_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_values() const;
  void _internal_add_values(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_values();
  public:
  int64_t values(int index) const;
  void set_values(int index, int64_t value);
  void add_values(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_values();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > vars_;
  mutable std::atomic<int> _vars_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > values_;
  mutable std::atomic<int> _values_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class SparsePermutationProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.SparsePermutationProto) */ {
 public:
  inline SparsePermutationProto() : SparsePermutationProto(nullptr) {}
  ~SparsePermutationProto() override;
  explicit constexpr SparsePermutationProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SparsePermutationProto(const SparsePermutationProto& from);
  SparsePermutationProto(SparsePermutationProto&& from) noexcept
    : SparsePermutationProto() {
    *this = ::std::move(from);
  }

  inline SparsePermutationProto& operator=(const SparsePermutationProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SparsePermutationProto& operator=(SparsePermutationProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SparsePermutationProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const SparsePermutationProto* internal_default_instance() {
    return reinterpret_cast<const SparsePermutationProto*>(
               &_SparsePermutationProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  friend void swap(SparsePermutationProto& a, SparsePermutationProto& b) {
    a.Swap(&b);
  }
  inline void Swap(SparsePermutationProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SparsePermutationProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SparsePermutationProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SparsePermutationProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SparsePermutationProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SparsePermutationProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SparsePermutationProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.SparsePermutationProto";
  }
  protected:
  explicit SparsePermutationProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSupportFieldNumber = 1,
    kCycleSizesFieldNumber = 2,
  };
  // repeated int32 support = 1;
  int support_size() const;
  private:
  int _internal_support_size() const;
  public:
  void clear_support();
  private:
  int32_t _internal_support(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_support() const;
  void _internal_add_support(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_support();
  public:
  int32_t support(int index) const;
  void set_support(int index, int32_t value);
  void add_support(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      support() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_support();

  // repeated int32 cycle_sizes = 2;
  int cycle_sizes_size() const;
  private:
  int _internal_cycle_sizes_size() const;
  public:
  void clear_cycle_sizes();
  private:
  int32_t _internal_cycle_sizes(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_cycle_sizes() const;
  void _internal_add_cycle_sizes(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_cycle_sizes();
  public:
  int32_t cycle_sizes(int index) const;
  void set_cycle_sizes(int index, int32_t value);
  void add_cycle_sizes(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      cycle_sizes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_cycle_sizes();

  // @@protoc_insertion_point(class_scope:operations_research.sat.SparsePermutationProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > support_;
  mutable std::atomic<int> _support_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > cycle_sizes_;
  mutable std::atomic<int> _cycle_sizes_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class DenseMatrixProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.DenseMatrixProto) */ {
 public:
  inline DenseMatrixProto() : DenseMatrixProto(nullptr) {}
  ~DenseMatrixProto() override;
  explicit constexpr DenseMatrixProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  DenseMatrixProto(const DenseMatrixProto& from);
  DenseMatrixProto(DenseMatrixProto&& from) noexcept
    : DenseMatrixProto() {
    *this = ::std::move(from);
  }

  inline DenseMatrixProto& operator=(const DenseMatrixProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DenseMatrixProto& operator=(DenseMatrixProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const DenseMatrixProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const DenseMatrixProto* internal_default_instance() {
    return reinterpret_cast<const DenseMatrixProto*>(
               &_DenseMatrixProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  friend void swap(DenseMatrixProto& a, DenseMatrixProto& b) {
    a.Swap(&b);
  }
  inline void Swap(DenseMatrixProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(DenseMatrixProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  DenseMatrixProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<DenseMatrixProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const DenseMatrixProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const DenseMatrixProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(DenseMatrixProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.DenseMatrixProto";
  }
  protected:
  explicit DenseMatrixProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kEntriesFieldNumber = 3,
    kNumRowsFieldNumber = 1,
    kNumColsFieldNumber = 2,
  };
  // repeated int32 entries = 3;
  int entries_size() const;
  private:
  int _internal_entries_size() const;
  public:
  void clear_entries();
  private:
  int32_t _internal_entries(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_entries() const;
  void _internal_add_entries(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_entries();
  public:
  int32_t entries(int index) const;
  void set_entries(int index, int32_t value);
  void add_entries(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      entries() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_entries();

  // int32 num_rows = 1;
  void clear_num_rows();
  int32_t num_rows() const;
  void set_num_rows(int32_t value);
  private:
  int32_t _internal_num_rows() const;
  void _internal_set_num_rows(int32_t value);
  public:

  // int32 num_cols = 2;
  void clear_num_cols();
  int32_t num_cols() const;
  void set_num_cols(int32_t value);
  private:
  int32_t _internal_num_cols() const;
  void _internal_set_num_cols(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:operations_research.sat.DenseMatrixProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > entries_;
  mutable std::atomic<int> _entries_cached_byte_size_;
  int32_t num_rows_;
  int32_t num_cols_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class SymmetryProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.SymmetryProto) */ {
 public:
  inline SymmetryProto() : SymmetryProto(nullptr) {}
  ~SymmetryProto() override;
  explicit constexpr SymmetryProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SymmetryProto(const SymmetryProto& from);
  SymmetryProto(SymmetryProto&& from) noexcept
    : SymmetryProto() {
    *this = ::std::move(from);
  }

  inline SymmetryProto& operator=(const SymmetryProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SymmetryProto& operator=(SymmetryProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SymmetryProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const SymmetryProto* internal_default_instance() {
    return reinterpret_cast<const SymmetryProto*>(
               &_SymmetryProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  friend void swap(SymmetryProto& a, SymmetryProto& b) {
    a.Swap(&b);
  }
  inline void Swap(SymmetryProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SymmetryProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  SymmetryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SymmetryProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SymmetryProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SymmetryProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SymmetryProto* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.SymmetryProto";
  }
  protected:
  explicit SymmetryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kPermutationsFieldNumber = 1,
    kOrbitopesFieldNumber = 2,
  };
  // repeated .operations_research.sat.SparsePermutationProto permutations = 1;
  int permutations_size() const;
  private:
  int _internal_permutations_size() const;
  public:
  void clear_permutations();
  ::operations_research::sat::SparsePermutationProto* mutable_permutations(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::SparsePermutationProto >*
      mutable_permutations();
  private:
  const ::operations_research::sat::SparsePermutationProto& _internal_permutations(int index) const;
  ::operations_research::sat::SparsePermutationProto* _internal_add_permutations();
  public:
  const ::operations_research::sat::SparsePermutationProto& permutations(int index) const;
  ::operations_research::sat::SparsePermutationProto* add_permutations();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::SparsePermutationProto >&
      permutations() const;

  // repeated .operations_research.sat.DenseMatrixProto orbitopes = 2;
  int orbitopes_size() const;
  private:
  int _internal_orbitopes_size() const;
  public:
  void clear_orbitopes();
  ::operations_research::sat::DenseMatrixProto* mutable_orbitopes(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DenseMatrixProto >*
      mutable_orbitopes();
  private:
  const ::operations_research::sat::DenseMatrixProto& _internal_orbitopes(int index) const;
  ::operations_research::sat::DenseMatrixProto* _internal_add_orbitopes();
  public:
  const ::operations_research::sat::DenseMatrixProto& orbitopes(int index) const;
  ::operations_research::sat::DenseMatrixProto* add_orbitopes();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DenseMatrixProto >&
      orbitopes() const;

  // @@protoc_insertion_point(class_scope:operations_research.sat.SymmetryProto)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::SparsePermutationProto > permutations_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DenseMatrixProto > orbitopes_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CpModelProto final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CpModelProto) */ {
 public:
  inline CpModelProto() : CpModelProto(nullptr) {}
  ~CpModelProto() override;
  explicit constexpr CpModelProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CpModelProto(const CpModelProto& from);
  CpModelProto(CpModelProto&& from) noexcept
    : CpModelProto() {
    *this = ::std::move(from);
  }

  inline CpModelProto& operator=(const CpModelProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline CpModelProto& operator=(CpModelProto&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CpModelProto& default_instance() {
    return *internal_default_instance();
  }
  static inline const CpModelProto* internal_default_instance() {
    return reinterpret_cast<const CpModelProto*>(
               &_CpModelProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  friend void swap(CpModelProto& a, CpModelProto& b) {
    a.Swap(&b);
  }
  inline void Swap(CpModelProto* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CpModelProto* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CpModelProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CpModelProto>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CpModelProto& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CpModelProto& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.CpModelProto";
  }
  protected:
  explicit CpModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kVariablesFieldNumber = 2,
    kConstraintsFieldNumber = 3,
    kSearchStrategyFieldNumber = 5,
    kAssumptionsFieldNumber = 7,
    kNameFieldNumber = 1,
    kObjectiveFieldNumber = 4,
    kSolutionHintFieldNumber = 6,
    kSymmetryFieldNumber = 8,
    kFloatingPointObjectiveFieldNumber = 9,
  };
  // repeated .operations_research.sat.IntegerVariableProto variables = 2;
  int variables_size() const;
  private:
  int _internal_variables_size() const;
  public:
  void clear_variables();
  ::operations_research::sat::IntegerVariableProto* mutable_variables(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >*
      mutable_variables();
  private:
  const ::operations_research::sat::IntegerVariableProto& _internal_variables(int index) const;
  ::operations_research::sat::IntegerVariableProto* _internal_add_variables();
  public:
  const ::operations_research::sat::IntegerVariableProto& variables(int index) const;
  ::operations_research::sat::IntegerVariableProto* add_variables();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >&
      variables() const;

  // repeated .operations_research.sat.ConstraintProto constraints = 3;
  int constraints_size() const;
  private:
  int _internal_constraints_size() const;
  public:
  void clear_constraints();
  ::operations_research::sat::ConstraintProto* mutable_constraints(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::ConstraintProto >*
      mutable_constraints();
  private:
  const ::operations_research::sat::ConstraintProto& _internal_constraints(int index) const;
  ::operations_research::sat::ConstraintProto* _internal_add_constraints();
  public:
  const ::operations_research::sat::ConstraintProto& constraints(int index) const;
  ::operations_research::sat::ConstraintProto* add_constraints();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::ConstraintProto >&
      constraints() const;

  // repeated .operations_research.sat.DecisionStrategyProto search_strategy = 5;
  int search_strategy_size() const;
  private:
  int _internal_search_strategy_size() const;
  public:
  void clear_search_strategy();
  ::operations_research::sat::DecisionStrategyProto* mutable_search_strategy(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto >*
      mutable_search_strategy();
  private:
  const ::operations_research::sat::DecisionStrategyProto& _internal_search_strategy(int index) const;
  ::operations_research::sat::DecisionStrategyProto* _internal_add_search_strategy();
  public:
  const ::operations_research::sat::DecisionStrategyProto& search_strategy(int index) const;
  ::operations_research::sat::DecisionStrategyProto* add_search_strategy();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto >&
      search_strategy() const;

  // repeated int32 assumptions = 7;
  int assumptions_size() const;
  private:
  int _internal_assumptions_size() const;
  public:
  void clear_assumptions();
  private:
  int32_t _internal_assumptions(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_assumptions() const;
  void _internal_add_assumptions(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_assumptions();
  public:
  int32_t assumptions(int index) const;
  void set_assumptions(int index, int32_t value);
  void add_assumptions(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      assumptions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_assumptions();

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .operations_research.sat.CpObjectiveProto objective = 4;
  bool has_objective() const;
  private:
  bool _internal_has_objective() const;
  public:
  void clear_objective();
  const ::operations_research::sat::CpObjectiveProto& objective() const;
  PROTOBUF_NODISCARD ::operations_research::sat::CpObjectiveProto* release_objective();
  ::operations_research::sat::CpObjectiveProto* mutable_objective();
  void set_allocated_objective(::operations_research::sat::CpObjectiveProto* objective);
  private:
  const ::operations_research::sat::CpObjectiveProto& _internal_objective() const;
  ::operations_research::sat::CpObjectiveProto* _internal_mutable_objective();
  public:
  void unsafe_arena_set_allocated_objective(
      ::operations_research::sat::CpObjectiveProto* objective);
  ::operations_research::sat::CpObjectiveProto* unsafe_arena_release_objective();

  // .operations_research.sat.PartialVariableAssignment solution_hint = 6;
  bool has_solution_hint() const;
  private:
  bool _internal_has_solution_hint() const;
  public:
  void clear_solution_hint();
  const ::operations_research::sat::PartialVariableAssignment& solution_hint() const;
  PROTOBUF_NODISCARD ::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);
  private:
  const ::operations_research::sat::PartialVariableAssignment& _internal_solution_hint() const;
  ::operations_research::sat::PartialVariableAssignment* _internal_mutable_solution_hint();
  public:
  void unsafe_arena_set_allocated_solution_hint(
      ::operations_research::sat::PartialVariableAssignment* solution_hint);
  ::operations_research::sat::PartialVariableAssignment* unsafe_arena_release_solution_hint();

  // .operations_research.sat.SymmetryProto symmetry = 8;
  bool has_symmetry() const;
  private:
  bool _internal_has_symmetry() const;
  public:
  void clear_symmetry();
  const ::operations_research::sat::SymmetryProto& symmetry() const;
  PROTOBUF_NODISCARD ::operations_research::sat::SymmetryProto* release_symmetry();
  ::operations_research::sat::SymmetryProto* mutable_symmetry();
  void set_allocated_symmetry(::operations_research::sat::SymmetryProto* symmetry);
  private:
  const ::operations_research::sat::SymmetryProto& _internal_symmetry() const;
  ::operations_research::sat::SymmetryProto* _internal_mutable_symmetry();
  public:
  void unsafe_arena_set_allocated_symmetry(
      ::operations_research::sat::SymmetryProto* symmetry);
  ::operations_research::sat::SymmetryProto* unsafe_arena_release_symmetry();

  // .operations_research.sat.FloatObjectiveProto floating_point_objective = 9;
  bool has_floating_point_objective() const;
  private:
  bool _internal_has_floating_point_objective() const;
  public:
  void clear_floating_point_objective();
  const ::operations_research::sat::FloatObjectiveProto& floating_point_objective() const;
  PROTOBUF_NODISCARD ::operations_research::sat::FloatObjectiveProto* release_floating_point_objective();
  ::operations_research::sat::FloatObjectiveProto* mutable_floating_point_objective();
  void set_allocated_floating_point_objective(::operations_research::sat::FloatObjectiveProto* floating_point_objective);
  private:
  const ::operations_research::sat::FloatObjectiveProto& _internal_floating_point_objective() const;
  ::operations_research::sat::FloatObjectiveProto* _internal_mutable_floating_point_objective();
  public:
  void unsafe_arena_set_allocated_floating_point_objective(
      ::operations_research::sat::FloatObjectiveProto* floating_point_objective);
  ::operations_research::sat::FloatObjectiveProto* unsafe_arena_release_floating_point_objective();

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto > variables_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::ConstraintProto > constraints_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DecisionStrategyProto > search_strategy_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > assumptions_;
  mutable std::atomic<int> _assumptions_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::operations_research::sat::CpObjectiveProto* objective_;
  ::operations_research::sat::PartialVariableAssignment* solution_hint_;
  ::operations_research::sat::SymmetryProto* symmetry_;
  ::operations_research::sat::FloatObjectiveProto* floating_point_objective_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CpSolverSolution final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CpSolverSolution) */ {
 public:
  inline CpSolverSolution() : CpSolverSolution(nullptr) {}
  ~CpSolverSolution() override;
  explicit constexpr CpSolverSolution(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CpSolverSolution(const CpSolverSolution& from);
  CpSolverSolution(CpSolverSolution&& from) noexcept
    : CpSolverSolution() {
    *this = ::std::move(from);
  }

  inline CpSolverSolution& operator=(const CpSolverSolution& from) {
    CopyFrom(from);
    return *this;
  }
  inline CpSolverSolution& operator=(CpSolverSolution&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CpSolverSolution& default_instance() {
    return *internal_default_instance();
  }
  static inline const CpSolverSolution* internal_default_instance() {
    return reinterpret_cast<const CpSolverSolution*>(
               &_CpSolverSolution_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  friend void swap(CpSolverSolution& a, CpSolverSolution& b) {
    a.Swap(&b);
  }
  inline void Swap(CpSolverSolution* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CpSolverSolution* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CpSolverSolution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CpSolverSolution>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CpSolverSolution& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CpSolverSolution& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CpSolverSolution* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.CpSolverSolution";
  }
  protected:
  explicit CpSolverSolution(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kValuesFieldNumber = 1,
  };
  // repeated int64 values = 1;
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  private:
  int64_t _internal_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_values() const;
  void _internal_add_values(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_values();
  public:
  int64_t values(int index) const;
  void set_values(int index, int64_t value);
  void add_values(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_values();

  // @@protoc_insertion_point(class_scope:operations_research.sat.CpSolverSolution)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > values_;
  mutable std::atomic<int> _values_cached_byte_size_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ortools_2fsat_2fcp_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class CpSolverResponse final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.CpSolverResponse) */ {
 public:
  inline CpSolverResponse() : CpSolverResponse(nullptr) {}
  ~CpSolverResponse() override;
  explicit constexpr CpSolverResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CpSolverResponse(const CpSolverResponse& from);
  CpSolverResponse(CpSolverResponse&& from) noexcept
    : CpSolverResponse() {
    *this = ::std::move(from);
  }

  inline CpSolverResponse& operator=(const CpSolverResponse& from) {
    CopyFrom(from);
    return *this;
  }
  inline CpSolverResponse& operator=(CpSolverResponse&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CpSolverResponse& default_instance() {
    return *internal_default_instance();
  }
  static inline const CpSolverResponse* internal_default_instance() {
    return reinterpret_cast<const CpSolverResponse*>(
               &_CpSolverResponse_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  friend void swap(CpSolverResponse& a, CpSolverResponse& b) {
    a.Swap(&b);
  }
  inline void Swap(CpSolverResponse* other) {
    if (other == this) return;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CpSolverResponse* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  CpSolverResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<CpSolverResponse>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CpSolverResponse& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CpSolverResponse& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.CpSolverResponse";
  }
  protected:
  explicit CpSolverResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

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

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

  enum : int {
    kSolutionFieldNumber = 2,
    kTightenedVariablesFieldNumber = 21,
    kSufficientAssumptionsForInfeasibilityFieldNumber = 23,
    kAdditionalSolutionsFieldNumber = 27,
    kSolutionInfoFieldNumber = 20,
    kSolveLogFieldNumber = 26,
    kIntegerObjectiveFieldNumber = 28,
    kObjectiveValueFieldNumber = 3,
    kBestObjectiveBoundFieldNumber = 4,
    kNumBooleansFieldNumber = 10,
    kNumConflictsFieldNumber = 11,
    kNumBranchesFieldNumber = 12,
    kNumBinaryPropagationsFieldNumber = 13,
    kNumIntegerPropagationsFieldNumber = 14,
    kWallTimeFieldNumber = 15,
    kUserTimeFieldNumber = 16,
    kDeterministicTimeFieldNumber = 17,
    kGapIntegralFieldNumber = 22,
    kStatusFieldNumber = 1,
    kNumRestartsFieldNumber = 24,
    kNumLpIterationsFieldNumber = 25,
    kInnerObjectiveLowerBoundFieldNumber = 29,
  };
  // repeated int64 solution = 2;
  int solution_size() const;
  private:
  int _internal_solution_size() const;
  public:
  void clear_solution();
  private:
  int64_t _internal_solution(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      _internal_solution() const;
  void _internal_add_solution(int64_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      _internal_mutable_solution();
  public:
  int64_t solution(int index) const;
  void set_solution(int index, int64_t value);
  void add_solution(int64_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
      solution() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
      mutable_solution();

  // repeated .operations_research.sat.IntegerVariableProto tightened_variables = 21;
  int tightened_variables_size() const;
  private:
  int _internal_tightened_variables_size() const;
  public:
  void clear_tightened_variables();
  ::operations_research::sat::IntegerVariableProto* mutable_tightened_variables(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >*
      mutable_tightened_variables();
  private:
  const ::operations_research::sat::IntegerVariableProto& _internal_tightened_variables(int index) const;
  ::operations_research::sat::IntegerVariableProto* _internal_add_tightened_variables();
  public:
  const ::operations_research::sat::IntegerVariableProto& tightened_variables(int index) const;
  ::operations_research::sat::IntegerVariableProto* add_tightened_variables();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >&
      tightened_variables() const;

  // repeated int32 sufficient_assumptions_for_infeasibility = 23;
  int sufficient_assumptions_for_infeasibility_size() const;
  private:
  int _internal_sufficient_assumptions_for_infeasibility_size() const;
  public:
  void clear_sufficient_assumptions_for_infeasibility();
  private:
  int32_t _internal_sufficient_assumptions_for_infeasibility(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_sufficient_assumptions_for_infeasibility() const;
  void _internal_add_sufficient_assumptions_for_infeasibility(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_sufficient_assumptions_for_infeasibility();
  public:
  int32_t sufficient_assumptions_for_infeasibility(int index) const;
  void set_sufficient_assumptions_for_infeasibility(int index, int32_t value);
  void add_sufficient_assumptions_for_infeasibility(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      sufficient_assumptions_for_infeasibility() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_sufficient_assumptions_for_infeasibility();

  // repeated .operations_research.sat.CpSolverSolution additional_solutions = 27;
  int additional_solutions_size() const;
  private:
  int _internal_additional_solutions_size() const;
  public:
  void clear_additional_solutions();
  ::operations_research::sat::CpSolverSolution* mutable_additional_solutions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::CpSolverSolution >*
      mutable_additional_solutions();
  private:
  const ::operations_research::sat::CpSolverSolution& _internal_additional_solutions(int index) const;
  ::operations_research::sat::CpSolverSolution* _internal_add_additional_solutions();
  public:
  const ::operations_research::sat::CpSolverSolution& additional_solutions(int index) const;
  ::operations_research::sat::CpSolverSolution* add_additional_solutions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::CpSolverSolution >&
      additional_solutions() const;

  // string solution_info = 20;
  void clear_solution_info();
  const std::string& solution_info() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_solution_info(ArgT0&& arg0, ArgT... args);
  std::string* mutable_solution_info();
  PROTOBUF_NODISCARD std::string* release_solution_info();
  void set_allocated_solution_info(std::string* solution_info);
  private:
  const std::string& _internal_solution_info() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_solution_info(const std::string& value);
  std::string* _internal_mutable_solution_info();
  public:

  // string solve_log = 26;
  void clear_solve_log();
  const std::string& solve_log() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_solve_log(ArgT0&& arg0, ArgT... args);
  std::string* mutable_solve_log();
  PROTOBUF_NODISCARD std::string* release_solve_log();
  void set_allocated_solve_log(std::string* solve_log);
  private:
  const std::string& _internal_solve_log() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_solve_log(const std::string& value);
  std::string* _internal_mutable_solve_log();
  public:

  // .operations_research.sat.CpObjectiveProto integer_objective = 28;
  bool has_integer_objective() const;
  private:
  bool _internal_has_integer_objective() const;
  public:
  void clear_integer_objective();
  const ::operations_research::sat::CpObjectiveProto& integer_objective() const;
  PROTOBUF_NODISCARD ::operations_research::sat::CpObjectiveProto* release_integer_objective();
  ::operations_research::sat::CpObjectiveProto* mutable_integer_objective();
  void set_allocated_integer_objective(::operations_research::sat::CpObjectiveProto* integer_objective);
  private:
  const ::operations_research::sat::CpObjectiveProto& _internal_integer_objective() const;
  ::operations_research::sat::CpObjectiveProto* _internal_mutable_integer_objective();
  public:
  void unsafe_arena_set_allocated_integer_objective(
      ::operations_research::sat::CpObjectiveProto* integer_objective);
  ::operations_research::sat::CpObjectiveProto* unsafe_arena_release_integer_objective();

  // double objective_value = 3;
  void clear_objective_value();
  double objective_value() const;
  void set_objective_value(double value);
  private:
  double _internal_objective_value() const;
  void _internal_set_objective_value(double value);
  public:

  // double best_objective_bound = 4;
  void clear_best_objective_bound();
  double best_objective_bound() const;
  void set_best_objective_bound(double value);
  private:
  double _internal_best_objective_bound() const;
  void _internal_set_best_objective_bound(double value);
  public:

  // int64 num_booleans = 10;
  void clear_num_booleans();
  int64_t num_booleans() const;
  void set_num_booleans(int64_t value);
  private:
  int64_t _internal_num_booleans() const;
  void _internal_set_num_booleans(int64_t value);
  public:

  // int64 num_conflicts = 11;
  void clear_num_conflicts();
  int64_t num_conflicts() const;
  void set_num_conflicts(int64_t value);
  private:
  int64_t _internal_num_conflicts() const;
  void _internal_set_num_conflicts(int64_t value);
  public:

  // int64 num_branches = 12;
  void clear_num_branches();
  int64_t num_branches() const;
  void set_num_branches(int64_t value);
  private:
  int64_t _internal_num_branches() const;
  void _internal_set_num_branches(int64_t value);
  public:

  // int64 num_binary_propagations = 13;
  void clear_num_binary_propagations();
  int64_t num_binary_propagations() const;
  void set_num_binary_propagations(int64_t value);
  private:
  int64_t _internal_num_binary_propagations() const;
  void _internal_set_num_binary_propagations(int64_t value);
  public:

  // int64 num_integer_propagations = 14;
  void clear_num_integer_propagations();
  int64_t num_integer_propagations() const;
  void set_num_integer_propagations(int64_t value);
  private:
  int64_t _internal_num_integer_propagations() const;
  void _internal_set_num_integer_propagations(int64_t value);
  public:

  // double wall_time = 15;
  void clear_wall_time();
  double wall_time() const;
  void set_wall_time(double value);
  private:
  double _internal_wall_time() const;
  void _internal_set_wall_time(double value);
  public:

  // double user_time = 16;
  void clear_user_time();
  double user_time() const;
  void set_user_time(double value);
  private:
  double _internal_user_time() const;
  void _internal_set_user_time(double value);
  public:

  // double deterministic_time = 17;
  void clear_deterministic_time();
  double deterministic_time() const;
  void set_deterministic_time(double value);
  private:
  double _internal_deterministic_time() const;
  void _internal_set_deterministic_time(double value);
  public:

  // double gap_integral = 22;
  void clear_gap_integral();
  double gap_integral() const;
  void set_gap_integral(double value);
  private:
  double _internal_gap_integral() const;
  void _internal_set_gap_integral(double value);
  public:

  // .operations_research.sat.CpSolverStatus status = 1;
  void clear_status();
  ::operations_research::sat::CpSolverStatus status() const;
  void set_status(::operations_research::sat::CpSolverStatus value);
  private:
  ::operations_research::sat::CpSolverStatus _internal_status() const;
  void _internal_set_status(::operations_research::sat::CpSolverStatus value);
  public:

  // int64 num_restarts = 24;
  void clear_num_restarts();
  int64_t num_restarts() const;
  void set_num_restarts(int64_t value);
  private:
  int64_t _internal_num_restarts() const;
  void _internal_set_num_restarts(int64_t value);
  public:

  // int64 num_lp_iterations = 25;
  void clear_num_lp_iterations();
  int64_t num_lp_iterations() const;
  void set_num_lp_iterations(int64_t value);
  private:
  int64_t _internal_num_lp_iterations() const;
  void _internal_set_num_lp_iterations(int64_t value);
  public:

  // int64 inner_objective_lower_bound = 29;
  void clear_inner_objective_lower_bound();
  int64_t inner_objective_lower_bound() const;
  void set_inner_objective_lower_bound(int64_t value);
  private:
  int64_t _internal_inner_objective_lower_bound() const;
  void _internal_set_inner_objective_lower_bound(int64_t value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > solution_;
  mutable std::atomic<int> _solution_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto > tightened_variables_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > sufficient_assumptions_for_infeasibility_;
  mutable std::atomic<int> _sufficient_assumptions_for_infeasibility_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::CpSolverSolution > additional_solutions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr solution_info_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr solve_log_;
  ::operations_research::sat::CpObjectiveProto* integer_objective_;
  double objective_value_;
  double best_objective_bound_;
  int64_t num_booleans_;
  int64_t num_conflicts_;
  int64_t num_branches_;
  int64_t num_binary_propagations_;
  int64_t num_integer_propagations_;
  double wall_time_;
  double user_time_;
  double deterministic_time_;
  double gap_integral_;
  int status_;
  int64_t num_restarts_;
  int64_t num_lp_iterations_;
  int64_t inner_objective_lower_bound_;
  mutable ::PROTOBUF_NAMESPACE_ID::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_.ClearToEmpty();
}
inline const std::string& IntegerVariableProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntegerVariableProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void IntegerVariableProto::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.sat.IntegerVariableProto.name)
}
inline std::string* IntegerVariableProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.IntegerVariableProto.name)
  return _s;
}
inline const std::string& IntegerVariableProto::_internal_name() const {
  return name_.Get();
}
inline void IntegerVariableProto::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* IntegerVariableProto::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* IntegerVariableProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.sat.IntegerVariableProto.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void IntegerVariableProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.IntegerVariableProto.name)
}

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

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

// BoolArgumentProto

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

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

// LinearExpressionProto

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

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

// int64 offset = 3;
inline void LinearExpressionProto::clear_offset() {
  offset_ = int64_t{0};
}
inline int64_t LinearExpressionProto::_internal_offset() const {
  return offset_;
}
inline int64_t LinearExpressionProto::offset() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.LinearExpressionProto.offset)
  return _internal_offset();
}
inline void LinearExpressionProto::_internal_set_offset(int64_t value) {
  
  offset_ = value;
}
inline void LinearExpressionProto::set_offset(int64_t value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.LinearExpressionProto.offset)
}

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

// LinearArgumentProto

// .operations_research.sat.LinearExpressionProto target = 1;
inline bool LinearArgumentProto::_internal_has_target() const {
  return this != internal_default_instance() && target_ != nullptr;
}
inline bool LinearArgumentProto::has_target() const {
  return _internal_has_target();
}
inline void LinearArgumentProto::clear_target() {
  if (GetArenaForAllocation() == nullptr && target_ != nullptr) {
    delete target_;
  }
  target_ = nullptr;
}
inline const ::operations_research::sat::LinearExpressionProto& LinearArgumentProto::_internal_target() const {
  const ::operations_research::sat::LinearExpressionProto* p = target_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::LinearExpressionProto&>(
      ::operations_research::sat::_LinearExpressionProto_default_instance_);
}
inline const ::operations_research::sat::LinearExpressionProto& LinearArgumentProto::target() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.LinearArgumentProto.target)
  return _internal_target();
}
inline void LinearArgumentProto::unsafe_arena_set_allocated_target(
    ::operations_research::sat::LinearExpressionProto* target) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(target_);
  }
  target_ = target;
  if (target) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.LinearArgumentProto.target)
}
inline ::operations_research::sat::LinearExpressionProto* LinearArgumentProto::release_target() {
  
  ::operations_research::sat::LinearExpressionProto* temp = target_;
  target_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* LinearArgumentProto::unsafe_arena_release_target() {
  // @@protoc_insertion_point(field_release:operations_research.sat.LinearArgumentProto.target)
  
  ::operations_research::sat::LinearExpressionProto* temp = target_;
  target_ = nullptr;
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* LinearArgumentProto::_internal_mutable_target() {
  
  if (target_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::LinearExpressionProto>(GetArenaForAllocation());
    target_ = p;
  }
  return target_;
}
inline ::operations_research::sat::LinearExpressionProto* LinearArgumentProto::mutable_target() {
  ::operations_research::sat::LinearExpressionProto* _msg = _internal_mutable_target();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.LinearArgumentProto.target)
  return _msg;
}
inline void LinearArgumentProto::set_allocated_target(::operations_research::sat::LinearExpressionProto* target) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete target_;
  }
  if (target) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::LinearExpressionProto>::GetOwningArena(target);
    if (message_arena != submessage_arena) {
      target = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, target, submessage_arena);
    }
    
  } else {
    
  }
  target_ = target;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.LinearArgumentProto.target)
}

// repeated .operations_research.sat.LinearExpressionProto exprs = 2;
inline int LinearArgumentProto::_internal_exprs_size() const {
  return exprs_.size();
}
inline int LinearArgumentProto::exprs_size() const {
  return _internal_exprs_size();
}
inline void LinearArgumentProto::clear_exprs() {
  exprs_.Clear();
}
inline ::operations_research::sat::LinearExpressionProto* LinearArgumentProto::mutable_exprs(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.LinearArgumentProto.exprs)
  return exprs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >*
LinearArgumentProto::mutable_exprs() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.LinearArgumentProto.exprs)
  return &exprs_;
}
inline const ::operations_research::sat::LinearExpressionProto& LinearArgumentProto::_internal_exprs(int index) const {
  return exprs_.Get(index);
}
inline const ::operations_research::sat::LinearExpressionProto& LinearArgumentProto::exprs(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.LinearArgumentProto.exprs)
  return _internal_exprs(index);
}
inline ::operations_research::sat::LinearExpressionProto* LinearArgumentProto::_internal_add_exprs() {
  return exprs_.Add();
}
inline ::operations_research::sat::LinearExpressionProto* LinearArgumentProto::add_exprs() {
  ::operations_research::sat::LinearExpressionProto* _add = _internal_add_exprs();
  // @@protoc_insertion_point(field_add:operations_research.sat.LinearArgumentProto.exprs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >&
LinearArgumentProto::exprs() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.LinearArgumentProto.exprs)
  return exprs_;
}

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

// AllDifferentConstraintProto

// repeated .operations_research.sat.LinearExpressionProto exprs = 1;
inline int AllDifferentConstraintProto::_internal_exprs_size() const {
  return exprs_.size();
}
inline int AllDifferentConstraintProto::exprs_size() const {
  return _internal_exprs_size();
}
inline void AllDifferentConstraintProto::clear_exprs() {
  exprs_.Clear();
}
inline ::operations_research::sat::LinearExpressionProto* AllDifferentConstraintProto::mutable_exprs(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.AllDifferentConstraintProto.exprs)
  return exprs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >*
AllDifferentConstraintProto::mutable_exprs() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.AllDifferentConstraintProto.exprs)
  return &exprs_;
}
inline const ::operations_research::sat::LinearExpressionProto& AllDifferentConstraintProto::_internal_exprs(int index) const {
  return exprs_.Get(index);
}
inline const ::operations_research::sat::LinearExpressionProto& AllDifferentConstraintProto::exprs(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.AllDifferentConstraintProto.exprs)
  return _internal_exprs(index);
}
inline ::operations_research::sat::LinearExpressionProto* AllDifferentConstraintProto::_internal_add_exprs() {
  return exprs_.Add();
}
inline ::operations_research::sat::LinearExpressionProto* AllDifferentConstraintProto::add_exprs() {
  ::operations_research::sat::LinearExpressionProto* _add = _internal_add_exprs();
  // @@protoc_insertion_point(field_add:operations_research.sat.AllDifferentConstraintProto.exprs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >&
AllDifferentConstraintProto::exprs() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.AllDifferentConstraintProto.exprs)
  return exprs_;
}

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

// LinearConstraintProto

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

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

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

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

// ElementConstraintProto

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

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

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

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

// IntervalConstraintProto

// .operations_research.sat.LinearExpressionProto start = 4;
inline bool IntervalConstraintProto::_internal_has_start() const {
  return this != internal_default_instance() && start_ != nullptr;
}
inline bool IntervalConstraintProto::has_start() const {
  return _internal_has_start();
}
inline void IntervalConstraintProto::clear_start() {
  if (GetArenaForAllocation() == nullptr && start_ != nullptr) {
    delete start_;
  }
  start_ = nullptr;
}
inline const ::operations_research::sat::LinearExpressionProto& IntervalConstraintProto::_internal_start() const {
  const ::operations_research::sat::LinearExpressionProto* p = start_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::LinearExpressionProto&>(
      ::operations_research::sat::_LinearExpressionProto_default_instance_);
}
inline const ::operations_research::sat::LinearExpressionProto& IntervalConstraintProto::start() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntervalConstraintProto.start)
  return _internal_start();
}
inline void IntervalConstraintProto::unsafe_arena_set_allocated_start(
    ::operations_research::sat::LinearExpressionProto* start) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(start_);
  }
  start_ = start;
  if (start) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.IntervalConstraintProto.start)
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::release_start() {
  
  ::operations_research::sat::LinearExpressionProto* temp = start_;
  start_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::unsafe_arena_release_start() {
  // @@protoc_insertion_point(field_release:operations_research.sat.IntervalConstraintProto.start)
  
  ::operations_research::sat::LinearExpressionProto* temp = start_;
  start_ = nullptr;
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::_internal_mutable_start() {
  
  if (start_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::LinearExpressionProto>(GetArenaForAllocation());
    start_ = p;
  }
  return start_;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::mutable_start() {
  ::operations_research::sat::LinearExpressionProto* _msg = _internal_mutable_start();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.IntervalConstraintProto.start)
  return _msg;
}
inline void IntervalConstraintProto::set_allocated_start(::operations_research::sat::LinearExpressionProto* start) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete start_;
  }
  if (start) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::LinearExpressionProto>::GetOwningArena(start);
    if (message_arena != submessage_arena) {
      start = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, start, submessage_arena);
    }
    
  } else {
    
  }
  start_ = start;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.IntervalConstraintProto.start)
}

// .operations_research.sat.LinearExpressionProto end = 5;
inline bool IntervalConstraintProto::_internal_has_end() const {
  return this != internal_default_instance() && end_ != nullptr;
}
inline bool IntervalConstraintProto::has_end() const {
  return _internal_has_end();
}
inline void IntervalConstraintProto::clear_end() {
  if (GetArenaForAllocation() == nullptr && end_ != nullptr) {
    delete end_;
  }
  end_ = nullptr;
}
inline const ::operations_research::sat::LinearExpressionProto& IntervalConstraintProto::_internal_end() const {
  const ::operations_research::sat::LinearExpressionProto* p = end_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::LinearExpressionProto&>(
      ::operations_research::sat::_LinearExpressionProto_default_instance_);
}
inline const ::operations_research::sat::LinearExpressionProto& IntervalConstraintProto::end() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntervalConstraintProto.end)
  return _internal_end();
}
inline void IntervalConstraintProto::unsafe_arena_set_allocated_end(
    ::operations_research::sat::LinearExpressionProto* end) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(end_);
  }
  end_ = end;
  if (end) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.IntervalConstraintProto.end)
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::release_end() {
  
  ::operations_research::sat::LinearExpressionProto* temp = end_;
  end_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::unsafe_arena_release_end() {
  // @@protoc_insertion_point(field_release:operations_research.sat.IntervalConstraintProto.end)
  
  ::operations_research::sat::LinearExpressionProto* temp = end_;
  end_ = nullptr;
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::_internal_mutable_end() {
  
  if (end_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::LinearExpressionProto>(GetArenaForAllocation());
    end_ = p;
  }
  return end_;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::mutable_end() {
  ::operations_research::sat::LinearExpressionProto* _msg = _internal_mutable_end();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.IntervalConstraintProto.end)
  return _msg;
}
inline void IntervalConstraintProto::set_allocated_end(::operations_research::sat::LinearExpressionProto* end) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete end_;
  }
  if (end) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::LinearExpressionProto>::GetOwningArena(end);
    if (message_arena != submessage_arena) {
      end = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, end, submessage_arena);
    }
    
  } else {
    
  }
  end_ = end;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.IntervalConstraintProto.end)
}

// .operations_research.sat.LinearExpressionProto size = 6;
inline bool IntervalConstraintProto::_internal_has_size() const {
  return this != internal_default_instance() && size_ != nullptr;
}
inline bool IntervalConstraintProto::has_size() const {
  return _internal_has_size();
}
inline void IntervalConstraintProto::clear_size() {
  if (GetArenaForAllocation() == nullptr && size_ != nullptr) {
    delete size_;
  }
  size_ = nullptr;
}
inline const ::operations_research::sat::LinearExpressionProto& IntervalConstraintProto::_internal_size() const {
  const ::operations_research::sat::LinearExpressionProto* p = size_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::LinearExpressionProto&>(
      ::operations_research::sat::_LinearExpressionProto_default_instance_);
}
inline const ::operations_research::sat::LinearExpressionProto& IntervalConstraintProto::size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.IntervalConstraintProto.size)
  return _internal_size();
}
inline void IntervalConstraintProto::unsafe_arena_set_allocated_size(
    ::operations_research::sat::LinearExpressionProto* size) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(size_);
  }
  size_ = size;
  if (size) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.IntervalConstraintProto.size)
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::release_size() {
  
  ::operations_research::sat::LinearExpressionProto* temp = size_;
  size_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::unsafe_arena_release_size() {
  // @@protoc_insertion_point(field_release:operations_research.sat.IntervalConstraintProto.size)
  
  ::operations_research::sat::LinearExpressionProto* temp = size_;
  size_ = nullptr;
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::_internal_mutable_size() {
  
  if (size_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::LinearExpressionProto>(GetArenaForAllocation());
    size_ = p;
  }
  return size_;
}
inline ::operations_research::sat::LinearExpressionProto* IntervalConstraintProto::mutable_size() {
  ::operations_research::sat::LinearExpressionProto* _msg = _internal_mutable_size();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.IntervalConstraintProto.size)
  return _msg;
}
inline void IntervalConstraintProto::set_allocated_size(::operations_research::sat::LinearExpressionProto* size) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete size_;
  }
  if (size) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::LinearExpressionProto>::GetOwningArena(size);
    if (message_arena != submessage_arena) {
      size = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, size, submessage_arena);
    }
    
  } else {
    
  }
  size_ = size;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.IntervalConstraintProto.size)
}

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

// NoOverlapConstraintProto

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

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

// NoOverlap2DConstraintProto

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

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

// bool boxes_with_null_area_can_overlap = 3;
inline void NoOverlap2DConstraintProto::clear_boxes_with_null_area_can_overlap() {
  boxes_with_null_area_can_overlap_ = false;
}
inline bool NoOverlap2DConstraintProto::_internal_boxes_with_null_area_can_overlap() const {
  return boxes_with_null_area_can_overlap_;
}
inline bool NoOverlap2DConstraintProto::boxes_with_null_area_can_overlap() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.NoOverlap2DConstraintProto.boxes_with_null_area_can_overlap)
  return _internal_boxes_with_null_area_can_overlap();
}
inline void NoOverlap2DConstraintProto::_internal_set_boxes_with_null_area_can_overlap(bool value) {
  
  boxes_with_null_area_can_overlap_ = value;
}
inline void NoOverlap2DConstraintProto::set_boxes_with_null_area_can_overlap(bool value) {
  _internal_set_boxes_with_null_area_can_overlap(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.NoOverlap2DConstraintProto.boxes_with_null_area_can_overlap)
}

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

// CumulativeConstraintProto

// .operations_research.sat.LinearExpressionProto capacity = 1;
inline bool CumulativeConstraintProto::_internal_has_capacity() const {
  return this != internal_default_instance() && capacity_ != nullptr;
}
inline bool CumulativeConstraintProto::has_capacity() const {
  return _internal_has_capacity();
}
inline void CumulativeConstraintProto::clear_capacity() {
  if (GetArenaForAllocation() == nullptr && capacity_ != nullptr) {
    delete capacity_;
  }
  capacity_ = nullptr;
}
inline const ::operations_research::sat::LinearExpressionProto& CumulativeConstraintProto::_internal_capacity() const {
  const ::operations_research::sat::LinearExpressionProto* p = capacity_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::LinearExpressionProto&>(
      ::operations_research::sat::_LinearExpressionProto_default_instance_);
}
inline const ::operations_research::sat::LinearExpressionProto& CumulativeConstraintProto::capacity() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CumulativeConstraintProto.capacity)
  return _internal_capacity();
}
inline void CumulativeConstraintProto::unsafe_arena_set_allocated_capacity(
    ::operations_research::sat::LinearExpressionProto* capacity) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(capacity_);
  }
  capacity_ = capacity;
  if (capacity) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.CumulativeConstraintProto.capacity)
}
inline ::operations_research::sat::LinearExpressionProto* CumulativeConstraintProto::release_capacity() {
  
  ::operations_research::sat::LinearExpressionProto* temp = capacity_;
  capacity_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* CumulativeConstraintProto::unsafe_arena_release_capacity() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CumulativeConstraintProto.capacity)
  
  ::operations_research::sat::LinearExpressionProto* temp = capacity_;
  capacity_ = nullptr;
  return temp;
}
inline ::operations_research::sat::LinearExpressionProto* CumulativeConstraintProto::_internal_mutable_capacity() {
  
  if (capacity_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::LinearExpressionProto>(GetArenaForAllocation());
    capacity_ = p;
  }
  return capacity_;
}
inline ::operations_research::sat::LinearExpressionProto* CumulativeConstraintProto::mutable_capacity() {
  ::operations_research::sat::LinearExpressionProto* _msg = _internal_mutable_capacity();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CumulativeConstraintProto.capacity)
  return _msg;
}
inline void CumulativeConstraintProto::set_allocated_capacity(::operations_research::sat::LinearExpressionProto* capacity) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete capacity_;
  }
  if (capacity) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::LinearExpressionProto>::GetOwningArena(capacity);
    if (message_arena != submessage_arena) {
      capacity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, capacity, submessage_arena);
    }
    
  } else {
    
  }
  capacity_ = capacity;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CumulativeConstraintProto.capacity)
}

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

// repeated .operations_research.sat.LinearExpressionProto demands = 3;
inline int CumulativeConstraintProto::_internal_demands_size() const {
  return demands_.size();
}
inline int CumulativeConstraintProto::demands_size() const {
  return _internal_demands_size();
}
inline void CumulativeConstraintProto::clear_demands() {
  demands_.Clear();
}
inline ::operations_research::sat::LinearExpressionProto* CumulativeConstraintProto::mutable_demands(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CumulativeConstraintProto.demands)
  return demands_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >*
CumulativeConstraintProto::mutable_demands() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CumulativeConstraintProto.demands)
  return &demands_;
}
inline const ::operations_research::sat::LinearExpressionProto& CumulativeConstraintProto::_internal_demands(int index) const {
  return demands_.Get(index);
}
inline const ::operations_research::sat::LinearExpressionProto& CumulativeConstraintProto::demands(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CumulativeConstraintProto.demands)
  return _internal_demands(index);
}
inline ::operations_research::sat::LinearExpressionProto* CumulativeConstraintProto::_internal_add_demands() {
  return demands_.Add();
}
inline ::operations_research::sat::LinearExpressionProto* CumulativeConstraintProto::add_demands() {
  ::operations_research::sat::LinearExpressionProto* _add = _internal_add_demands();
  // @@protoc_insertion_point(field_add:operations_research.sat.CumulativeConstraintProto.demands)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >&
CumulativeConstraintProto::demands() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CumulativeConstraintProto.demands)
  return demands_;
}

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

// ReservoirConstraintProto

// int64 min_level = 1;
inline void ReservoirConstraintProto::clear_min_level() {
  min_level_ = int64_t{0};
}
inline int64_t ReservoirConstraintProto::_internal_min_level() const {
  return min_level_;
}
inline int64_t ReservoirConstraintProto::min_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.min_level)
  return _internal_min_level();
}
inline void ReservoirConstraintProto::_internal_set_min_level(int64_t value) {
  
  min_level_ = value;
}
inline void ReservoirConstraintProto::set_min_level(int64_t value) {
  _internal_set_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_ = int64_t{0};
}
inline int64_t ReservoirConstraintProto::_internal_max_level() const {
  return max_level_;
}
inline int64_t ReservoirConstraintProto::max_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.max_level)
  return _internal_max_level();
}
inline void ReservoirConstraintProto::_internal_set_max_level(int64_t value) {
  
  max_level_ = value;
}
inline void ReservoirConstraintProto::set_max_level(int64_t value) {
  _internal_set_max_level(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ReservoirConstraintProto.max_level)
}

// repeated .operations_research.sat.LinearExpressionProto time_exprs = 3;
inline int ReservoirConstraintProto::_internal_time_exprs_size() const {
  return time_exprs_.size();
}
inline int ReservoirConstraintProto::time_exprs_size() const {
  return _internal_time_exprs_size();
}
inline void ReservoirConstraintProto::clear_time_exprs() {
  time_exprs_.Clear();
}
inline ::operations_research::sat::LinearExpressionProto* ReservoirConstraintProto::mutable_time_exprs(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ReservoirConstraintProto.time_exprs)
  return time_exprs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >*
ReservoirConstraintProto::mutable_time_exprs() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.ReservoirConstraintProto.time_exprs)
  return &time_exprs_;
}
inline const ::operations_research::sat::LinearExpressionProto& ReservoirConstraintProto::_internal_time_exprs(int index) const {
  return time_exprs_.Get(index);
}
inline const ::operations_research::sat::LinearExpressionProto& ReservoirConstraintProto::time_exprs(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.time_exprs)
  return _internal_time_exprs(index);
}
inline ::operations_research::sat::LinearExpressionProto* ReservoirConstraintProto::_internal_add_time_exprs() {
  return time_exprs_.Add();
}
inline ::operations_research::sat::LinearExpressionProto* ReservoirConstraintProto::add_time_exprs() {
  ::operations_research::sat::LinearExpressionProto* _add = _internal_add_time_exprs();
  // @@protoc_insertion_point(field_add:operations_research.sat.ReservoirConstraintProto.time_exprs)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::LinearExpressionProto >&
ReservoirConstraintProto::time_exprs() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.ReservoirConstraintProto.time_exprs)
  return time_exprs_;
}

// repeated int64 level_changes = 4;
inline int ReservoirConstraintProto::_internal_level_changes_size() const {
  return level_changes_.size();
}
inline int ReservoirConstraintProto::level_changes_size() const {
  return _internal_level_changes_size();
}
inline void ReservoirConstraintProto::clear_level_changes() {
  level_changes_.Clear();
}
inline int64_t ReservoirConstraintProto::_internal_level_changes(int index) const {
  return level_changes_.Get(index);
}
inline int64_t ReservoirConstraintProto::level_changes(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.level_changes)
  return _internal_level_changes(index);
}
inline void ReservoirConstraintProto::set_level_changes(int index, int64_t value) {
  level_changes_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ReservoirConstraintProto.level_changes)
}
inline void ReservoirConstraintProto::_internal_add_level_changes(int64_t value) {
  level_changes_.Add(value);
}
inline void ReservoirConstraintProto::add_level_changes(int64_t value) {
  _internal_add_level_changes(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.ReservoirConstraintProto.level_changes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
ReservoirConstraintProto::_internal_level_changes() const {
  return level_changes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
ReservoirConstraintProto::level_changes() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.ReservoirConstraintProto.level_changes)
  return _internal_level_changes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
ReservoirConstraintProto::_internal_mutable_level_changes() {
  return &level_changes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
ReservoirConstraintProto::mutable_level_changes() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.ReservoirConstraintProto.level_changes)
  return _internal_mutable_level_changes();
}

// repeated int32 active_literals = 5;
inline int ReservoirConstraintProto::_internal_active_literals_size() const {
  return active_literals_.size();
}
inline int ReservoirConstraintProto::active_literals_size() const {
  return _internal_active_literals_size();
}
inline void ReservoirConstraintProto::clear_active_literals() {
  active_literals_.Clear();
}
inline int32_t ReservoirConstraintProto::_internal_active_literals(int index) const {
  return active_literals_.Get(index);
}
inline int32_t ReservoirConstraintProto::active_literals(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ReservoirConstraintProto.active_literals)
  return _internal_active_literals(index);
}
inline void ReservoirConstraintProto::set_active_literals(int index, int32_t value) {
  active_literals_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.ReservoirConstraintProto.active_literals)
}
inline void ReservoirConstraintProto::_internal_add_active_literals(int32_t value) {
  active_literals_.Add(value);
}
inline void ReservoirConstraintProto::add_active_literals(int32_t value) {
  _internal_add_active_literals(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.ReservoirConstraintProto.active_literals)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReservoirConstraintProto::_internal_active_literals() const {
  return active_literals_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
ReservoirConstraintProto::active_literals() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.ReservoirConstraintProto.active_literals)
  return _internal_active_literals();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReservoirConstraintProto::_internal_mutable_active_literals() {
  return &active_literals_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
ReservoirConstraintProto::mutable_active_literals() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.ReservoirConstraintProto.active_literals)
  return _internal_mutable_active_literals();
}

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

// CircuitConstraintProto

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

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

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

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

// RoutesConstraintProto

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

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

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

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

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

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

// TableConstraintProto

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

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

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

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

// InverseConstraintProto

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

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

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

// AutomatonConstraintProto

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

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

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

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

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

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

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

// ListOfVariablesProto

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

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

// ConstraintProto

// string name = 1;
inline void ConstraintProto::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& ConstraintProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void ConstraintProto::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.sat.ConstraintProto.name)
}
inline std::string* ConstraintProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.name)
  return _s;
}
inline const std::string& ConstraintProto::_internal_name() const {
  return name_.Get();
}
inline void ConstraintProto::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* ConstraintProto::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* ConstraintProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void ConstraintProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.ConstraintProto.name)
}

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

// .operations_research.sat.BoolArgumentProto bool_or = 3;
inline bool ConstraintProto::_internal_has_bool_or() const {
  return constraint_case() == kBoolOr;
}
inline bool ConstraintProto::has_bool_or() const {
  return _internal_has_bool_or();
}
inline void ConstraintProto::set_has_bool_or() {
  _oneof_case_[0] = kBoolOr;
}
inline void ConstraintProto::clear_bool_or() {
  if (_internal_has_bool_or()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_bool_or()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_or_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.bool_or_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::_internal_bool_or() const {
  return _internal_has_bool_or()
      ? *constraint_.bool_or_
      : reinterpret_cast< ::operations_research::sat::BoolArgumentProto&>(::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::bool_or() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.bool_or)
  return _internal_bool_or();
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::unsafe_arena_release_bool_or() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.bool_or)
  if (_internal_has_bool_or()) {
    clear_has_constraint();
    ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_or_;
    constraint_.bool_or_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_bool_or(::operations_research::sat::BoolArgumentProto* bool_or) {
  clear_constraint();
  if (bool_or) {
    set_has_bool_or();
    constraint_.bool_or_ = bool_or;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.bool_or)
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::_internal_mutable_bool_or() {
  if (!_internal_has_bool_or()) {
    clear_constraint();
    set_has_bool_or();
    constraint_.bool_or_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.bool_or_;
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_bool_or() {
  ::operations_research::sat::BoolArgumentProto* _msg = _internal_mutable_bool_or();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.bool_or)
  return _msg;
}

// .operations_research.sat.BoolArgumentProto bool_and = 4;
inline bool ConstraintProto::_internal_has_bool_and() const {
  return constraint_case() == kBoolAnd;
}
inline bool ConstraintProto::has_bool_and() const {
  return _internal_has_bool_and();
}
inline void ConstraintProto::set_has_bool_and() {
  _oneof_case_[0] = kBoolAnd;
}
inline void ConstraintProto::clear_bool_and() {
  if (_internal_has_bool_and()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_bool_and()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_and_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.bool_and_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::_internal_bool_and() const {
  return _internal_has_bool_and()
      ? *constraint_.bool_and_
      : reinterpret_cast< ::operations_research::sat::BoolArgumentProto&>(::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::bool_and() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.bool_and)
  return _internal_bool_and();
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::unsafe_arena_release_bool_and() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.bool_and)
  if (_internal_has_bool_and()) {
    clear_has_constraint();
    ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_and_;
    constraint_.bool_and_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_bool_and(::operations_research::sat::BoolArgumentProto* bool_and) {
  clear_constraint();
  if (bool_and) {
    set_has_bool_and();
    constraint_.bool_and_ = bool_and;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.bool_and)
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::_internal_mutable_bool_and() {
  if (!_internal_has_bool_and()) {
    clear_constraint();
    set_has_bool_and();
    constraint_.bool_and_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.bool_and_;
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_bool_and() {
  ::operations_research::sat::BoolArgumentProto* _msg = _internal_mutable_bool_and();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.bool_and)
  return _msg;
}

// .operations_research.sat.BoolArgumentProto at_most_one = 26;
inline bool ConstraintProto::_internal_has_at_most_one() const {
  return constraint_case() == kAtMostOne;
}
inline bool ConstraintProto::has_at_most_one() const {
  return _internal_has_at_most_one();
}
inline void ConstraintProto::set_has_at_most_one() {
  _oneof_case_[0] = kAtMostOne;
}
inline void ConstraintProto::clear_at_most_one() {
  if (_internal_has_at_most_one()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_at_most_one()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.at_most_one_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.at_most_one_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::_internal_at_most_one() const {
  return _internal_has_at_most_one()
      ? *constraint_.at_most_one_
      : reinterpret_cast< ::operations_research::sat::BoolArgumentProto&>(::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::at_most_one() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.at_most_one)
  return _internal_at_most_one();
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::unsafe_arena_release_at_most_one() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.at_most_one)
  if (_internal_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 void ConstraintProto::unsafe_arena_set_allocated_at_most_one(::operations_research::sat::BoolArgumentProto* at_most_one) {
  clear_constraint();
  if (at_most_one) {
    set_has_at_most_one();
    constraint_.at_most_one_ = at_most_one;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.at_most_one)
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::_internal_mutable_at_most_one() {
  if (!_internal_has_at_most_one()) {
    clear_constraint();
    set_has_at_most_one();
    constraint_.at_most_one_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.at_most_one_;
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_at_most_one() {
  ::operations_research::sat::BoolArgumentProto* _msg = _internal_mutable_at_most_one();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.at_most_one)
  return _msg;
}

// .operations_research.sat.BoolArgumentProto exactly_one = 29;
inline bool ConstraintProto::_internal_has_exactly_one() const {
  return constraint_case() == kExactlyOne;
}
inline bool ConstraintProto::has_exactly_one() const {
  return _internal_has_exactly_one();
}
inline void ConstraintProto::set_has_exactly_one() {
  _oneof_case_[0] = kExactlyOne;
}
inline void ConstraintProto::clear_exactly_one() {
  if (_internal_has_exactly_one()) {
    if (GetArenaForAllocation() == nullptr) {
      delete constraint_.exactly_one_;
    }
    clear_has_constraint();
  }
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::release_exactly_one() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.exactly_one)
  if (_internal_has_exactly_one()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.exactly_one_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.exactly_one_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::_internal_exactly_one() const {
  return _internal_has_exactly_one()
      ? *constraint_.exactly_one_
      : reinterpret_cast< ::operations_research::sat::BoolArgumentProto&>(::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::exactly_one() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.exactly_one)
  return _internal_exactly_one();
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::unsafe_arena_release_exactly_one() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.exactly_one)
  if (_internal_has_exactly_one()) {
    clear_has_constraint();
    ::operations_research::sat::BoolArgumentProto* temp = constraint_.exactly_one_;
    constraint_.exactly_one_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_exactly_one(::operations_research::sat::BoolArgumentProto* exactly_one) {
  clear_constraint();
  if (exactly_one) {
    set_has_exactly_one();
    constraint_.exactly_one_ = exactly_one;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.exactly_one)
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::_internal_mutable_exactly_one() {
  if (!_internal_has_exactly_one()) {
    clear_constraint();
    set_has_exactly_one();
    constraint_.exactly_one_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.exactly_one_;
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_exactly_one() {
  ::operations_research::sat::BoolArgumentProto* _msg = _internal_mutable_exactly_one();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.exactly_one)
  return _msg;
}

// .operations_research.sat.BoolArgumentProto bool_xor = 5;
inline bool ConstraintProto::_internal_has_bool_xor() const {
  return constraint_case() == kBoolXor;
}
inline bool ConstraintProto::has_bool_xor() const {
  return _internal_has_bool_xor();
}
inline void ConstraintProto::set_has_bool_xor() {
  _oneof_case_[0] = kBoolXor;
}
inline void ConstraintProto::clear_bool_xor() {
  if (_internal_has_bool_xor()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_bool_xor()) {
    clear_has_constraint();
      ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_xor_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.bool_xor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::_internal_bool_xor() const {
  return _internal_has_bool_xor()
      ? *constraint_.bool_xor_
      : reinterpret_cast< ::operations_research::sat::BoolArgumentProto&>(::operations_research::sat::_BoolArgumentProto_default_instance_);
}
inline const ::operations_research::sat::BoolArgumentProto& ConstraintProto::bool_xor() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.bool_xor)
  return _internal_bool_xor();
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::unsafe_arena_release_bool_xor() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.bool_xor)
  if (_internal_has_bool_xor()) {
    clear_has_constraint();
    ::operations_research::sat::BoolArgumentProto* temp = constraint_.bool_xor_;
    constraint_.bool_xor_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_bool_xor(::operations_research::sat::BoolArgumentProto* bool_xor) {
  clear_constraint();
  if (bool_xor) {
    set_has_bool_xor();
    constraint_.bool_xor_ = bool_xor;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.bool_xor)
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::_internal_mutable_bool_xor() {
  if (!_internal_has_bool_xor()) {
    clear_constraint();
    set_has_bool_xor();
    constraint_.bool_xor_ = CreateMaybeMessage< ::operations_research::sat::BoolArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.bool_xor_;
}
inline ::operations_research::sat::BoolArgumentProto* ConstraintProto::mutable_bool_xor() {
  ::operations_research::sat::BoolArgumentProto* _msg = _internal_mutable_bool_xor();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.bool_xor)
  return _msg;
}

// .operations_research.sat.LinearArgumentProto int_div = 7;
inline bool ConstraintProto::_internal_has_int_div() const {
  return constraint_case() == kIntDiv;
}
inline bool ConstraintProto::has_int_div() const {
  return _internal_has_int_div();
}
inline void ConstraintProto::set_has_int_div() {
  _oneof_case_[0] = kIntDiv;
}
inline void ConstraintProto::clear_int_div() {
  if (_internal_has_int_div()) {
    if (GetArenaForAllocation() == nullptr) {
      delete constraint_.int_div_;
    }
    clear_has_constraint();
  }
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::release_int_div() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.int_div)
  if (_internal_has_int_div()) {
    clear_has_constraint();
      ::operations_research::sat::LinearArgumentProto* temp = constraint_.int_div_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.int_div_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::LinearArgumentProto& ConstraintProto::_internal_int_div() const {
  return _internal_has_int_div()
      ? *constraint_.int_div_
      : reinterpret_cast< ::operations_research::sat::LinearArgumentProto&>(::operations_research::sat::_LinearArgumentProto_default_instance_);
}
inline const ::operations_research::sat::LinearArgumentProto& ConstraintProto::int_div() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.int_div)
  return _internal_int_div();
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::unsafe_arena_release_int_div() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.int_div)
  if (_internal_has_int_div()) {
    clear_has_constraint();
    ::operations_research::sat::LinearArgumentProto* temp = constraint_.int_div_;
    constraint_.int_div_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_int_div(::operations_research::sat::LinearArgumentProto* int_div) {
  clear_constraint();
  if (int_div) {
    set_has_int_div();
    constraint_.int_div_ = int_div;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.int_div)
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::_internal_mutable_int_div() {
  if (!_internal_has_int_div()) {
    clear_constraint();
    set_has_int_div();
    constraint_.int_div_ = CreateMaybeMessage< ::operations_research::sat::LinearArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.int_div_;
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::mutable_int_div() {
  ::operations_research::sat::LinearArgumentProto* _msg = _internal_mutable_int_div();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.int_div)
  return _msg;
}

// .operations_research.sat.LinearArgumentProto int_mod = 8;
inline bool ConstraintProto::_internal_has_int_mod() const {
  return constraint_case() == kIntMod;
}
inline bool ConstraintProto::has_int_mod() const {
  return _internal_has_int_mod();
}
inline void ConstraintProto::set_has_int_mod() {
  _oneof_case_[0] = kIntMod;
}
inline void ConstraintProto::clear_int_mod() {
  if (_internal_has_int_mod()) {
    if (GetArenaForAllocation() == nullptr) {
      delete constraint_.int_mod_;
    }
    clear_has_constraint();
  }
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::release_int_mod() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.int_mod)
  if (_internal_has_int_mod()) {
    clear_has_constraint();
      ::operations_research::sat::LinearArgumentProto* temp = constraint_.int_mod_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.int_mod_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::LinearArgumentProto& ConstraintProto::_internal_int_mod() const {
  return _internal_has_int_mod()
      ? *constraint_.int_mod_
      : reinterpret_cast< ::operations_research::sat::LinearArgumentProto&>(::operations_research::sat::_LinearArgumentProto_default_instance_);
}
inline const ::operations_research::sat::LinearArgumentProto& ConstraintProto::int_mod() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.int_mod)
  return _internal_int_mod();
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::unsafe_arena_release_int_mod() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.int_mod)
  if (_internal_has_int_mod()) {
    clear_has_constraint();
    ::operations_research::sat::LinearArgumentProto* temp = constraint_.int_mod_;
    constraint_.int_mod_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_int_mod(::operations_research::sat::LinearArgumentProto* int_mod) {
  clear_constraint();
  if (int_mod) {
    set_has_int_mod();
    constraint_.int_mod_ = int_mod;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.int_mod)
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::_internal_mutable_int_mod() {
  if (!_internal_has_int_mod()) {
    clear_constraint();
    set_has_int_mod();
    constraint_.int_mod_ = CreateMaybeMessage< ::operations_research::sat::LinearArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.int_mod_;
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::mutable_int_mod() {
  ::operations_research::sat::LinearArgumentProto* _msg = _internal_mutable_int_mod();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.int_mod)
  return _msg;
}

// .operations_research.sat.LinearArgumentProto int_prod = 11;
inline bool ConstraintProto::_internal_has_int_prod() const {
  return constraint_case() == kIntProd;
}
inline bool ConstraintProto::has_int_prod() const {
  return _internal_has_int_prod();
}
inline void ConstraintProto::set_has_int_prod() {
  _oneof_case_[0] = kIntProd;
}
inline void ConstraintProto::clear_int_prod() {
  if (_internal_has_int_prod()) {
    if (GetArenaForAllocation() == nullptr) {
      delete constraint_.int_prod_;
    }
    clear_has_constraint();
  }
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::release_int_prod() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.int_prod)
  if (_internal_has_int_prod()) {
    clear_has_constraint();
      ::operations_research::sat::LinearArgumentProto* temp = constraint_.int_prod_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.int_prod_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::LinearArgumentProto& ConstraintProto::_internal_int_prod() const {
  return _internal_has_int_prod()
      ? *constraint_.int_prod_
      : reinterpret_cast< ::operations_research::sat::LinearArgumentProto&>(::operations_research::sat::_LinearArgumentProto_default_instance_);
}
inline const ::operations_research::sat::LinearArgumentProto& ConstraintProto::int_prod() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.int_prod)
  return _internal_int_prod();
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::unsafe_arena_release_int_prod() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.int_prod)
  if (_internal_has_int_prod()) {
    clear_has_constraint();
    ::operations_research::sat::LinearArgumentProto* temp = constraint_.int_prod_;
    constraint_.int_prod_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_int_prod(::operations_research::sat::LinearArgumentProto* int_prod) {
  clear_constraint();
  if (int_prod) {
    set_has_int_prod();
    constraint_.int_prod_ = int_prod;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.int_prod)
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::_internal_mutable_int_prod() {
  if (!_internal_has_int_prod()) {
    clear_constraint();
    set_has_int_prod();
    constraint_.int_prod_ = CreateMaybeMessage< ::operations_research::sat::LinearArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.int_prod_;
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::mutable_int_prod() {
  ::operations_research::sat::LinearArgumentProto* _msg = _internal_mutable_int_prod();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.int_prod)
  return _msg;
}

// .operations_research.sat.LinearArgumentProto lin_max = 27;
inline bool ConstraintProto::_internal_has_lin_max() const {
  return constraint_case() == kLinMax;
}
inline bool ConstraintProto::has_lin_max() const {
  return _internal_has_lin_max();
}
inline void ConstraintProto::set_has_lin_max() {
  _oneof_case_[0] = kLinMax;
}
inline void ConstraintProto::clear_lin_max() {
  if (_internal_has_lin_max()) {
    if (GetArenaForAllocation() == nullptr) {
      delete constraint_.lin_max_;
    }
    clear_has_constraint();
  }
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::release_lin_max() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.lin_max)
  if (_internal_has_lin_max()) {
    clear_has_constraint();
      ::operations_research::sat::LinearArgumentProto* temp = constraint_.lin_max_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.lin_max_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::LinearArgumentProto& ConstraintProto::_internal_lin_max() const {
  return _internal_has_lin_max()
      ? *constraint_.lin_max_
      : reinterpret_cast< ::operations_research::sat::LinearArgumentProto&>(::operations_research::sat::_LinearArgumentProto_default_instance_);
}
inline const ::operations_research::sat::LinearArgumentProto& ConstraintProto::lin_max() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.lin_max)
  return _internal_lin_max();
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::unsafe_arena_release_lin_max() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.lin_max)
  if (_internal_has_lin_max()) {
    clear_has_constraint();
    ::operations_research::sat::LinearArgumentProto* temp = constraint_.lin_max_;
    constraint_.lin_max_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_lin_max(::operations_research::sat::LinearArgumentProto* lin_max) {
  clear_constraint();
  if (lin_max) {
    set_has_lin_max();
    constraint_.lin_max_ = lin_max;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.lin_max)
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::_internal_mutable_lin_max() {
  if (!_internal_has_lin_max()) {
    clear_constraint();
    set_has_lin_max();
    constraint_.lin_max_ = CreateMaybeMessage< ::operations_research::sat::LinearArgumentProto >(GetArenaForAllocation());
  }
  return constraint_.lin_max_;
}
inline ::operations_research::sat::LinearArgumentProto* ConstraintProto::mutable_lin_max() {
  ::operations_research::sat::LinearArgumentProto* _msg = _internal_mutable_lin_max();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.lin_max)
  return _msg;
}

// .operations_research.sat.LinearConstraintProto linear = 12;
inline bool ConstraintProto::_internal_has_linear() const {
  return constraint_case() == kLinear;
}
inline bool ConstraintProto::has_linear() const {
  return _internal_has_linear();
}
inline void ConstraintProto::set_has_linear() {
  _oneof_case_[0] = kLinear;
}
inline void ConstraintProto::clear_linear() {
  if (_internal_has_linear()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_linear()) {
    clear_has_constraint();
      ::operations_research::sat::LinearConstraintProto* temp = constraint_.linear_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.linear_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::LinearConstraintProto& ConstraintProto::_internal_linear() const {
  return _internal_has_linear()
      ? *constraint_.linear_
      : reinterpret_cast< ::operations_research::sat::LinearConstraintProto&>(::operations_research::sat::_LinearConstraintProto_default_instance_);
}
inline const ::operations_research::sat::LinearConstraintProto& ConstraintProto::linear() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.linear)
  return _internal_linear();
}
inline ::operations_research::sat::LinearConstraintProto* ConstraintProto::unsafe_arena_release_linear() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.linear)
  if (_internal_has_linear()) {
    clear_has_constraint();
    ::operations_research::sat::LinearConstraintProto* temp = constraint_.linear_;
    constraint_.linear_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_linear(::operations_research::sat::LinearConstraintProto* linear) {
  clear_constraint();
  if (linear) {
    set_has_linear();
    constraint_.linear_ = linear;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.linear)
}
inline ::operations_research::sat::LinearConstraintProto* ConstraintProto::_internal_mutable_linear() {
  if (!_internal_has_linear()) {
    clear_constraint();
    set_has_linear();
    constraint_.linear_ = CreateMaybeMessage< ::operations_research::sat::LinearConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.linear_;
}
inline ::operations_research::sat::LinearConstraintProto* ConstraintProto::mutable_linear() {
  ::operations_research::sat::LinearConstraintProto* _msg = _internal_mutable_linear();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.linear)
  return _msg;
}

// .operations_research.sat.AllDifferentConstraintProto all_diff = 13;
inline bool ConstraintProto::_internal_has_all_diff() const {
  return constraint_case() == kAllDiff;
}
inline bool ConstraintProto::has_all_diff() const {
  return _internal_has_all_diff();
}
inline void ConstraintProto::set_has_all_diff() {
  _oneof_case_[0] = kAllDiff;
}
inline void ConstraintProto::clear_all_diff() {
  if (_internal_has_all_diff()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_all_diff()) {
    clear_has_constraint();
      ::operations_research::sat::AllDifferentConstraintProto* temp = constraint_.all_diff_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.all_diff_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::AllDifferentConstraintProto& ConstraintProto::_internal_all_diff() const {
  return _internal_has_all_diff()
      ? *constraint_.all_diff_
      : reinterpret_cast< ::operations_research::sat::AllDifferentConstraintProto&>(::operations_research::sat::_AllDifferentConstraintProto_default_instance_);
}
inline const ::operations_research::sat::AllDifferentConstraintProto& ConstraintProto::all_diff() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.all_diff)
  return _internal_all_diff();
}
inline ::operations_research::sat::AllDifferentConstraintProto* ConstraintProto::unsafe_arena_release_all_diff() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.all_diff)
  if (_internal_has_all_diff()) {
    clear_has_constraint();
    ::operations_research::sat::AllDifferentConstraintProto* temp = constraint_.all_diff_;
    constraint_.all_diff_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_all_diff(::operations_research::sat::AllDifferentConstraintProto* all_diff) {
  clear_constraint();
  if (all_diff) {
    set_has_all_diff();
    constraint_.all_diff_ = all_diff;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.all_diff)
}
inline ::operations_research::sat::AllDifferentConstraintProto* ConstraintProto::_internal_mutable_all_diff() {
  if (!_internal_has_all_diff()) {
    clear_constraint();
    set_has_all_diff();
    constraint_.all_diff_ = CreateMaybeMessage< ::operations_research::sat::AllDifferentConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.all_diff_;
}
inline ::operations_research::sat::AllDifferentConstraintProto* ConstraintProto::mutable_all_diff() {
  ::operations_research::sat::AllDifferentConstraintProto* _msg = _internal_mutable_all_diff();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.all_diff)
  return _msg;
}

// .operations_research.sat.ElementConstraintProto element = 14;
inline bool ConstraintProto::_internal_has_element() const {
  return constraint_case() == kElement;
}
inline bool ConstraintProto::has_element() const {
  return _internal_has_element();
}
inline void ConstraintProto::set_has_element() {
  _oneof_case_[0] = kElement;
}
inline void ConstraintProto::clear_element() {
  if (_internal_has_element()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_element()) {
    clear_has_constraint();
      ::operations_research::sat::ElementConstraintProto* temp = constraint_.element_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.element_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::ElementConstraintProto& ConstraintProto::_internal_element() const {
  return _internal_has_element()
      ? *constraint_.element_
      : reinterpret_cast< ::operations_research::sat::ElementConstraintProto&>(::operations_research::sat::_ElementConstraintProto_default_instance_);
}
inline const ::operations_research::sat::ElementConstraintProto& ConstraintProto::element() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.element)
  return _internal_element();
}
inline ::operations_research::sat::ElementConstraintProto* ConstraintProto::unsafe_arena_release_element() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.element)
  if (_internal_has_element()) {
    clear_has_constraint();
    ::operations_research::sat::ElementConstraintProto* temp = constraint_.element_;
    constraint_.element_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_element(::operations_research::sat::ElementConstraintProto* element) {
  clear_constraint();
  if (element) {
    set_has_element();
    constraint_.element_ = element;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.element)
}
inline ::operations_research::sat::ElementConstraintProto* ConstraintProto::_internal_mutable_element() {
  if (!_internal_has_element()) {
    clear_constraint();
    set_has_element();
    constraint_.element_ = CreateMaybeMessage< ::operations_research::sat::ElementConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.element_;
}
inline ::operations_research::sat::ElementConstraintProto* ConstraintProto::mutable_element() {
  ::operations_research::sat::ElementConstraintProto* _msg = _internal_mutable_element();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.element)
  return _msg;
}

// .operations_research.sat.CircuitConstraintProto circuit = 15;
inline bool ConstraintProto::_internal_has_circuit() const {
  return constraint_case() == kCircuit;
}
inline bool ConstraintProto::has_circuit() const {
  return _internal_has_circuit();
}
inline void ConstraintProto::set_has_circuit() {
  _oneof_case_[0] = kCircuit;
}
inline void ConstraintProto::clear_circuit() {
  if (_internal_has_circuit()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_circuit()) {
    clear_has_constraint();
      ::operations_research::sat::CircuitConstraintProto* temp = constraint_.circuit_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.circuit_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::CircuitConstraintProto& ConstraintProto::_internal_circuit() const {
  return _internal_has_circuit()
      ? *constraint_.circuit_
      : reinterpret_cast< ::operations_research::sat::CircuitConstraintProto&>(::operations_research::sat::_CircuitConstraintProto_default_instance_);
}
inline const ::operations_research::sat::CircuitConstraintProto& ConstraintProto::circuit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.circuit)
  return _internal_circuit();
}
inline ::operations_research::sat::CircuitConstraintProto* ConstraintProto::unsafe_arena_release_circuit() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.circuit)
  if (_internal_has_circuit()) {
    clear_has_constraint();
    ::operations_research::sat::CircuitConstraintProto* temp = constraint_.circuit_;
    constraint_.circuit_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_circuit(::operations_research::sat::CircuitConstraintProto* circuit) {
  clear_constraint();
  if (circuit) {
    set_has_circuit();
    constraint_.circuit_ = circuit;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.circuit)
}
inline ::operations_research::sat::CircuitConstraintProto* ConstraintProto::_internal_mutable_circuit() {
  if (!_internal_has_circuit()) {
    clear_constraint();
    set_has_circuit();
    constraint_.circuit_ = CreateMaybeMessage< ::operations_research::sat::CircuitConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.circuit_;
}
inline ::operations_research::sat::CircuitConstraintProto* ConstraintProto::mutable_circuit() {
  ::operations_research::sat::CircuitConstraintProto* _msg = _internal_mutable_circuit();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.circuit)
  return _msg;
}

// .operations_research.sat.RoutesConstraintProto routes = 23;
inline bool ConstraintProto::_internal_has_routes() const {
  return constraint_case() == kRoutes;
}
inline bool ConstraintProto::has_routes() const {
  return _internal_has_routes();
}
inline void ConstraintProto::set_has_routes() {
  _oneof_case_[0] = kRoutes;
}
inline void ConstraintProto::clear_routes() {
  if (_internal_has_routes()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_routes()) {
    clear_has_constraint();
      ::operations_research::sat::RoutesConstraintProto* temp = constraint_.routes_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.routes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::RoutesConstraintProto& ConstraintProto::_internal_routes() const {
  return _internal_has_routes()
      ? *constraint_.routes_
      : reinterpret_cast< ::operations_research::sat::RoutesConstraintProto&>(::operations_research::sat::_RoutesConstraintProto_default_instance_);
}
inline const ::operations_research::sat::RoutesConstraintProto& ConstraintProto::routes() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.routes)
  return _internal_routes();
}
inline ::operations_research::sat::RoutesConstraintProto* ConstraintProto::unsafe_arena_release_routes() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.routes)
  if (_internal_has_routes()) {
    clear_has_constraint();
    ::operations_research::sat::RoutesConstraintProto* temp = constraint_.routes_;
    constraint_.routes_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_routes(::operations_research::sat::RoutesConstraintProto* routes) {
  clear_constraint();
  if (routes) {
    set_has_routes();
    constraint_.routes_ = routes;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.routes)
}
inline ::operations_research::sat::RoutesConstraintProto* ConstraintProto::_internal_mutable_routes() {
  if (!_internal_has_routes()) {
    clear_constraint();
    set_has_routes();
    constraint_.routes_ = CreateMaybeMessage< ::operations_research::sat::RoutesConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.routes_;
}
inline ::operations_research::sat::RoutesConstraintProto* ConstraintProto::mutable_routes() {
  ::operations_research::sat::RoutesConstraintProto* _msg = _internal_mutable_routes();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.routes)
  return _msg;
}

// .operations_research.sat.TableConstraintProto table = 16;
inline bool ConstraintProto::_internal_has_table() const {
  return constraint_case() == kTable;
}
inline bool ConstraintProto::has_table() const {
  return _internal_has_table();
}
inline void ConstraintProto::set_has_table() {
  _oneof_case_[0] = kTable;
}
inline void ConstraintProto::clear_table() {
  if (_internal_has_table()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_table()) {
    clear_has_constraint();
      ::operations_research::sat::TableConstraintProto* temp = constraint_.table_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.table_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::TableConstraintProto& ConstraintProto::_internal_table() const {
  return _internal_has_table()
      ? *constraint_.table_
      : reinterpret_cast< ::operations_research::sat::TableConstraintProto&>(::operations_research::sat::_TableConstraintProto_default_instance_);
}
inline const ::operations_research::sat::TableConstraintProto& ConstraintProto::table() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.table)
  return _internal_table();
}
inline ::operations_research::sat::TableConstraintProto* ConstraintProto::unsafe_arena_release_table() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.table)
  if (_internal_has_table()) {
    clear_has_constraint();
    ::operations_research::sat::TableConstraintProto* temp = constraint_.table_;
    constraint_.table_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_table(::operations_research::sat::TableConstraintProto* table) {
  clear_constraint();
  if (table) {
    set_has_table();
    constraint_.table_ = table;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.table)
}
inline ::operations_research::sat::TableConstraintProto* ConstraintProto::_internal_mutable_table() {
  if (!_internal_has_table()) {
    clear_constraint();
    set_has_table();
    constraint_.table_ = CreateMaybeMessage< ::operations_research::sat::TableConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.table_;
}
inline ::operations_research::sat::TableConstraintProto* ConstraintProto::mutable_table() {
  ::operations_research::sat::TableConstraintProto* _msg = _internal_mutable_table();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.table)
  return _msg;
}

// .operations_research.sat.AutomatonConstraintProto automaton = 17;
inline bool ConstraintProto::_internal_has_automaton() const {
  return constraint_case() == kAutomaton;
}
inline bool ConstraintProto::has_automaton() const {
  return _internal_has_automaton();
}
inline void ConstraintProto::set_has_automaton() {
  _oneof_case_[0] = kAutomaton;
}
inline void ConstraintProto::clear_automaton() {
  if (_internal_has_automaton()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_automaton()) {
    clear_has_constraint();
      ::operations_research::sat::AutomatonConstraintProto* temp = constraint_.automaton_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.automaton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::AutomatonConstraintProto& ConstraintProto::_internal_automaton() const {
  return _internal_has_automaton()
      ? *constraint_.automaton_
      : reinterpret_cast< ::operations_research::sat::AutomatonConstraintProto&>(::operations_research::sat::_AutomatonConstraintProto_default_instance_);
}
inline const ::operations_research::sat::AutomatonConstraintProto& ConstraintProto::automaton() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.automaton)
  return _internal_automaton();
}
inline ::operations_research::sat::AutomatonConstraintProto* ConstraintProto::unsafe_arena_release_automaton() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.automaton)
  if (_internal_has_automaton()) {
    clear_has_constraint();
    ::operations_research::sat::AutomatonConstraintProto* temp = constraint_.automaton_;
    constraint_.automaton_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_automaton(::operations_research::sat::AutomatonConstraintProto* automaton) {
  clear_constraint();
  if (automaton) {
    set_has_automaton();
    constraint_.automaton_ = automaton;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.automaton)
}
inline ::operations_research::sat::AutomatonConstraintProto* ConstraintProto::_internal_mutable_automaton() {
  if (!_internal_has_automaton()) {
    clear_constraint();
    set_has_automaton();
    constraint_.automaton_ = CreateMaybeMessage< ::operations_research::sat::AutomatonConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.automaton_;
}
inline ::operations_research::sat::AutomatonConstraintProto* ConstraintProto::mutable_automaton() {
  ::operations_research::sat::AutomatonConstraintProto* _msg = _internal_mutable_automaton();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.automaton)
  return _msg;
}

// .operations_research.sat.InverseConstraintProto inverse = 18;
inline bool ConstraintProto::_internal_has_inverse() const {
  return constraint_case() == kInverse;
}
inline bool ConstraintProto::has_inverse() const {
  return _internal_has_inverse();
}
inline void ConstraintProto::set_has_inverse() {
  _oneof_case_[0] = kInverse;
}
inline void ConstraintProto::clear_inverse() {
  if (_internal_has_inverse()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_inverse()) {
    clear_has_constraint();
      ::operations_research::sat::InverseConstraintProto* temp = constraint_.inverse_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.inverse_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::InverseConstraintProto& ConstraintProto::_internal_inverse() const {
  return _internal_has_inverse()
      ? *constraint_.inverse_
      : reinterpret_cast< ::operations_research::sat::InverseConstraintProto&>(::operations_research::sat::_InverseConstraintProto_default_instance_);
}
inline const ::operations_research::sat::InverseConstraintProto& ConstraintProto::inverse() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.inverse)
  return _internal_inverse();
}
inline ::operations_research::sat::InverseConstraintProto* ConstraintProto::unsafe_arena_release_inverse() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.inverse)
  if (_internal_has_inverse()) {
    clear_has_constraint();
    ::operations_research::sat::InverseConstraintProto* temp = constraint_.inverse_;
    constraint_.inverse_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_inverse(::operations_research::sat::InverseConstraintProto* inverse) {
  clear_constraint();
  if (inverse) {
    set_has_inverse();
    constraint_.inverse_ = inverse;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.inverse)
}
inline ::operations_research::sat::InverseConstraintProto* ConstraintProto::_internal_mutable_inverse() {
  if (!_internal_has_inverse()) {
    clear_constraint();
    set_has_inverse();
    constraint_.inverse_ = CreateMaybeMessage< ::operations_research::sat::InverseConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.inverse_;
}
inline ::operations_research::sat::InverseConstraintProto* ConstraintProto::mutable_inverse() {
  ::operations_research::sat::InverseConstraintProto* _msg = _internal_mutable_inverse();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.inverse)
  return _msg;
}

// .operations_research.sat.ReservoirConstraintProto reservoir = 24;
inline bool ConstraintProto::_internal_has_reservoir() const {
  return constraint_case() == kReservoir;
}
inline bool ConstraintProto::has_reservoir() const {
  return _internal_has_reservoir();
}
inline void ConstraintProto::set_has_reservoir() {
  _oneof_case_[0] = kReservoir;
}
inline void ConstraintProto::clear_reservoir() {
  if (_internal_has_reservoir()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_reservoir()) {
    clear_has_constraint();
      ::operations_research::sat::ReservoirConstraintProto* temp = constraint_.reservoir_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.reservoir_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::ReservoirConstraintProto& ConstraintProto::_internal_reservoir() const {
  return _internal_has_reservoir()
      ? *constraint_.reservoir_
      : reinterpret_cast< ::operations_research::sat::ReservoirConstraintProto&>(::operations_research::sat::_ReservoirConstraintProto_default_instance_);
}
inline const ::operations_research::sat::ReservoirConstraintProto& ConstraintProto::reservoir() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.reservoir)
  return _internal_reservoir();
}
inline ::operations_research::sat::ReservoirConstraintProto* ConstraintProto::unsafe_arena_release_reservoir() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.reservoir)
  if (_internal_has_reservoir()) {
    clear_has_constraint();
    ::operations_research::sat::ReservoirConstraintProto* temp = constraint_.reservoir_;
    constraint_.reservoir_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_reservoir(::operations_research::sat::ReservoirConstraintProto* reservoir) {
  clear_constraint();
  if (reservoir) {
    set_has_reservoir();
    constraint_.reservoir_ = reservoir;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.reservoir)
}
inline ::operations_research::sat::ReservoirConstraintProto* ConstraintProto::_internal_mutable_reservoir() {
  if (!_internal_has_reservoir()) {
    clear_constraint();
    set_has_reservoir();
    constraint_.reservoir_ = CreateMaybeMessage< ::operations_research::sat::ReservoirConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.reservoir_;
}
inline ::operations_research::sat::ReservoirConstraintProto* ConstraintProto::mutable_reservoir() {
  ::operations_research::sat::ReservoirConstraintProto* _msg = _internal_mutable_reservoir();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.reservoir)
  return _msg;
}

// .operations_research.sat.IntervalConstraintProto interval = 19;
inline bool ConstraintProto::_internal_has_interval() const {
  return constraint_case() == kInterval;
}
inline bool ConstraintProto::has_interval() const {
  return _internal_has_interval();
}
inline void ConstraintProto::set_has_interval() {
  _oneof_case_[0] = kInterval;
}
inline void ConstraintProto::clear_interval() {
  if (_internal_has_interval()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_interval()) {
    clear_has_constraint();
      ::operations_research::sat::IntervalConstraintProto* temp = constraint_.interval_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.interval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::IntervalConstraintProto& ConstraintProto::_internal_interval() const {
  return _internal_has_interval()
      ? *constraint_.interval_
      : reinterpret_cast< ::operations_research::sat::IntervalConstraintProto&>(::operations_research::sat::_IntervalConstraintProto_default_instance_);
}
inline const ::operations_research::sat::IntervalConstraintProto& ConstraintProto::interval() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.interval)
  return _internal_interval();
}
inline ::operations_research::sat::IntervalConstraintProto* ConstraintProto::unsafe_arena_release_interval() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.interval)
  if (_internal_has_interval()) {
    clear_has_constraint();
    ::operations_research::sat::IntervalConstraintProto* temp = constraint_.interval_;
    constraint_.interval_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_interval(::operations_research::sat::IntervalConstraintProto* interval) {
  clear_constraint();
  if (interval) {
    set_has_interval();
    constraint_.interval_ = interval;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.interval)
}
inline ::operations_research::sat::IntervalConstraintProto* ConstraintProto::_internal_mutable_interval() {
  if (!_internal_has_interval()) {
    clear_constraint();
    set_has_interval();
    constraint_.interval_ = CreateMaybeMessage< ::operations_research::sat::IntervalConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.interval_;
}
inline ::operations_research::sat::IntervalConstraintProto* ConstraintProto::mutable_interval() {
  ::operations_research::sat::IntervalConstraintProto* _msg = _internal_mutable_interval();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.interval)
  return _msg;
}

// .operations_research.sat.NoOverlapConstraintProto no_overlap = 20;
inline bool ConstraintProto::_internal_has_no_overlap() const {
  return constraint_case() == kNoOverlap;
}
inline bool ConstraintProto::has_no_overlap() const {
  return _internal_has_no_overlap();
}
inline void ConstraintProto::set_has_no_overlap() {
  _oneof_case_[0] = kNoOverlap;
}
inline void ConstraintProto::clear_no_overlap() {
  if (_internal_has_no_overlap()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_no_overlap()) {
    clear_has_constraint();
      ::operations_research::sat::NoOverlapConstraintProto* temp = constraint_.no_overlap_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.no_overlap_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::NoOverlapConstraintProto& ConstraintProto::_internal_no_overlap() const {
  return _internal_has_no_overlap()
      ? *constraint_.no_overlap_
      : reinterpret_cast< ::operations_research::sat::NoOverlapConstraintProto&>(::operations_research::sat::_NoOverlapConstraintProto_default_instance_);
}
inline const ::operations_research::sat::NoOverlapConstraintProto& ConstraintProto::no_overlap() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.no_overlap)
  return _internal_no_overlap();
}
inline ::operations_research::sat::NoOverlapConstraintProto* ConstraintProto::unsafe_arena_release_no_overlap() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.no_overlap)
  if (_internal_has_no_overlap()) {
    clear_has_constraint();
    ::operations_research::sat::NoOverlapConstraintProto* temp = constraint_.no_overlap_;
    constraint_.no_overlap_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_no_overlap(::operations_research::sat::NoOverlapConstraintProto* no_overlap) {
  clear_constraint();
  if (no_overlap) {
    set_has_no_overlap();
    constraint_.no_overlap_ = no_overlap;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.no_overlap)
}
inline ::operations_research::sat::NoOverlapConstraintProto* ConstraintProto::_internal_mutable_no_overlap() {
  if (!_internal_has_no_overlap()) {
    clear_constraint();
    set_has_no_overlap();
    constraint_.no_overlap_ = CreateMaybeMessage< ::operations_research::sat::NoOverlapConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.no_overlap_;
}
inline ::operations_research::sat::NoOverlapConstraintProto* ConstraintProto::mutable_no_overlap() {
  ::operations_research::sat::NoOverlapConstraintProto* _msg = _internal_mutable_no_overlap();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.no_overlap)
  return _msg;
}

// .operations_research.sat.NoOverlap2DConstraintProto no_overlap_2d = 21;
inline bool ConstraintProto::_internal_has_no_overlap_2d() const {
  return constraint_case() == kNoOverlap2D;
}
inline bool ConstraintProto::has_no_overlap_2d() const {
  return _internal_has_no_overlap_2d();
}
inline void ConstraintProto::set_has_no_overlap_2d() {
  _oneof_case_[0] = kNoOverlap2D;
}
inline void ConstraintProto::clear_no_overlap_2d() {
  if (_internal_has_no_overlap_2d()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_no_overlap_2d()) {
    clear_has_constraint();
      ::operations_research::sat::NoOverlap2DConstraintProto* temp = constraint_.no_overlap_2d_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.no_overlap_2d_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::NoOverlap2DConstraintProto& ConstraintProto::_internal_no_overlap_2d() const {
  return _internal_has_no_overlap_2d()
      ? *constraint_.no_overlap_2d_
      : reinterpret_cast< ::operations_research::sat::NoOverlap2DConstraintProto&>(::operations_research::sat::_NoOverlap2DConstraintProto_default_instance_);
}
inline const ::operations_research::sat::NoOverlap2DConstraintProto& ConstraintProto::no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.no_overlap_2d)
  return _internal_no_overlap_2d();
}
inline ::operations_research::sat::NoOverlap2DConstraintProto* ConstraintProto::unsafe_arena_release_no_overlap_2d() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.no_overlap_2d)
  if (_internal_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 void ConstraintProto::unsafe_arena_set_allocated_no_overlap_2d(::operations_research::sat::NoOverlap2DConstraintProto* no_overlap_2d) {
  clear_constraint();
  if (no_overlap_2d) {
    set_has_no_overlap_2d();
    constraint_.no_overlap_2d_ = no_overlap_2d;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.no_overlap_2d)
}
inline ::operations_research::sat::NoOverlap2DConstraintProto* ConstraintProto::_internal_mutable_no_overlap_2d() {
  if (!_internal_has_no_overlap_2d()) {
    clear_constraint();
    set_has_no_overlap_2d();
    constraint_.no_overlap_2d_ = CreateMaybeMessage< ::operations_research::sat::NoOverlap2DConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.no_overlap_2d_;
}
inline ::operations_research::sat::NoOverlap2DConstraintProto* ConstraintProto::mutable_no_overlap_2d() {
  ::operations_research::sat::NoOverlap2DConstraintProto* _msg = _internal_mutable_no_overlap_2d();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.no_overlap_2d)
  return _msg;
}

// .operations_research.sat.CumulativeConstraintProto cumulative = 22;
inline bool ConstraintProto::_internal_has_cumulative() const {
  return constraint_case() == kCumulative;
}
inline bool ConstraintProto::has_cumulative() const {
  return _internal_has_cumulative();
}
inline void ConstraintProto::set_has_cumulative() {
  _oneof_case_[0] = kCumulative;
}
inline void ConstraintProto::clear_cumulative() {
  if (_internal_has_cumulative()) {
    if (GetArenaForAllocation() == nullptr) {
      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 (_internal_has_cumulative()) {
    clear_has_constraint();
      ::operations_research::sat::CumulativeConstraintProto* temp = constraint_.cumulative_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.cumulative_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::CumulativeConstraintProto& ConstraintProto::_internal_cumulative() const {
  return _internal_has_cumulative()
      ? *constraint_.cumulative_
      : reinterpret_cast< ::operations_research::sat::CumulativeConstraintProto&>(::operations_research::sat::_CumulativeConstraintProto_default_instance_);
}
inline const ::operations_research::sat::CumulativeConstraintProto& ConstraintProto::cumulative() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.cumulative)
  return _internal_cumulative();
}
inline ::operations_research::sat::CumulativeConstraintProto* ConstraintProto::unsafe_arena_release_cumulative() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.cumulative)
  if (_internal_has_cumulative()) {
    clear_has_constraint();
    ::operations_research::sat::CumulativeConstraintProto* temp = constraint_.cumulative_;
    constraint_.cumulative_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_cumulative(::operations_research::sat::CumulativeConstraintProto* cumulative) {
  clear_constraint();
  if (cumulative) {
    set_has_cumulative();
    constraint_.cumulative_ = cumulative;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.cumulative)
}
inline ::operations_research::sat::CumulativeConstraintProto* ConstraintProto::_internal_mutable_cumulative() {
  if (!_internal_has_cumulative()) {
    clear_constraint();
    set_has_cumulative();
    constraint_.cumulative_ = CreateMaybeMessage< ::operations_research::sat::CumulativeConstraintProto >(GetArenaForAllocation());
  }
  return constraint_.cumulative_;
}
inline ::operations_research::sat::CumulativeConstraintProto* ConstraintProto::mutable_cumulative() {
  ::operations_research::sat::CumulativeConstraintProto* _msg = _internal_mutable_cumulative();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.cumulative)
  return _msg;
}

// .operations_research.sat.ListOfVariablesProto dummy_constraint = 30;
inline bool ConstraintProto::_internal_has_dummy_constraint() const {
  return constraint_case() == kDummyConstraint;
}
inline bool ConstraintProto::has_dummy_constraint() const {
  return _internal_has_dummy_constraint();
}
inline void ConstraintProto::set_has_dummy_constraint() {
  _oneof_case_[0] = kDummyConstraint;
}
inline void ConstraintProto::clear_dummy_constraint() {
  if (_internal_has_dummy_constraint()) {
    if (GetArenaForAllocation() == nullptr) {
      delete constraint_.dummy_constraint_;
    }
    clear_has_constraint();
  }
}
inline ::operations_research::sat::ListOfVariablesProto* ConstraintProto::release_dummy_constraint() {
  // @@protoc_insertion_point(field_release:operations_research.sat.ConstraintProto.dummy_constraint)
  if (_internal_has_dummy_constraint()) {
    clear_has_constraint();
      ::operations_research::sat::ListOfVariablesProto* temp = constraint_.dummy_constraint_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    constraint_.dummy_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::sat::ListOfVariablesProto& ConstraintProto::_internal_dummy_constraint() const {
  return _internal_has_dummy_constraint()
      ? *constraint_.dummy_constraint_
      : reinterpret_cast< ::operations_research::sat::ListOfVariablesProto&>(::operations_research::sat::_ListOfVariablesProto_default_instance_);
}
inline const ::operations_research::sat::ListOfVariablesProto& ConstraintProto::dummy_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.ConstraintProto.dummy_constraint)
  return _internal_dummy_constraint();
}
inline ::operations_research::sat::ListOfVariablesProto* ConstraintProto::unsafe_arena_release_dummy_constraint() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.ConstraintProto.dummy_constraint)
  if (_internal_has_dummy_constraint()) {
    clear_has_constraint();
    ::operations_research::sat::ListOfVariablesProto* temp = constraint_.dummy_constraint_;
    constraint_.dummy_constraint_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void ConstraintProto::unsafe_arena_set_allocated_dummy_constraint(::operations_research::sat::ListOfVariablesProto* dummy_constraint) {
  clear_constraint();
  if (dummy_constraint) {
    set_has_dummy_constraint();
    constraint_.dummy_constraint_ = dummy_constraint;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.ConstraintProto.dummy_constraint)
}
inline ::operations_research::sat::ListOfVariablesProto* ConstraintProto::_internal_mutable_dummy_constraint() {
  if (!_internal_has_dummy_constraint()) {
    clear_constraint();
    set_has_dummy_constraint();
    constraint_.dummy_constraint_ = CreateMaybeMessage< ::operations_research::sat::ListOfVariablesProto >(GetArenaForAllocation());
  }
  return constraint_.dummy_constraint_;
}
inline ::operations_research::sat::ListOfVariablesProto* ConstraintProto::mutable_dummy_constraint() {
  ::operations_research::sat::ListOfVariablesProto* _msg = _internal_mutable_dummy_constraint();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.ConstraintProto.dummy_constraint)
  return _msg;
}

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::_internal_vars_size() const {
  return vars_.size();
}
inline int CpObjectiveProto::vars_size() const {
  return _internal_vars_size();
}
inline void CpObjectiveProto::clear_vars() {
  vars_.Clear();
}
inline int32_t CpObjectiveProto::_internal_vars(int index) const {
  return vars_.Get(index);
}
inline int32_t CpObjectiveProto::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.vars)
  return _internal_vars(index);
}
inline void CpObjectiveProto::set_vars(int index, int32_t value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.vars)
}
inline void CpObjectiveProto::_internal_add_vars(int32_t value) {
  vars_.Add(value);
}
inline void CpObjectiveProto::add_vars(int32_t value) {
  _internal_add_vars(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpObjectiveProto.vars)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CpObjectiveProto::_internal_vars() const {
  return vars_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CpObjectiveProto::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpObjectiveProto.vars)
  return _internal_vars();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CpObjectiveProto::_internal_mutable_vars() {
  return &vars_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CpObjectiveProto::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpObjectiveProto.vars)
  return _internal_mutable_vars();
}

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

// double offset = 2;
inline void CpObjectiveProto::clear_offset() {
  offset_ = 0;
}
inline double CpObjectiveProto::_internal_offset() const {
  return offset_;
}
inline double CpObjectiveProto::offset() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.offset)
  return _internal_offset();
}
inline void CpObjectiveProto::_internal_set_offset(double value) {
  
  offset_ = value;
}
inline void CpObjectiveProto::set_offset(double value) {
  _internal_set_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::_internal_scaling_factor() const {
  return scaling_factor_;
}
inline double CpObjectiveProto::scaling_factor() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.scaling_factor)
  return _internal_scaling_factor();
}
inline void CpObjectiveProto::_internal_set_scaling_factor(double value) {
  
  scaling_factor_ = value;
}
inline void CpObjectiveProto::set_scaling_factor(double value) {
  _internal_set_scaling_factor(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.scaling_factor)
}

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

// bool scaling_was_exact = 6;
inline void CpObjectiveProto::clear_scaling_was_exact() {
  scaling_was_exact_ = false;
}
inline bool CpObjectiveProto::_internal_scaling_was_exact() const {
  return scaling_was_exact_;
}
inline bool CpObjectiveProto::scaling_was_exact() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.scaling_was_exact)
  return _internal_scaling_was_exact();
}
inline void CpObjectiveProto::_internal_set_scaling_was_exact(bool value) {
  
  scaling_was_exact_ = value;
}
inline void CpObjectiveProto::set_scaling_was_exact(bool value) {
  _internal_set_scaling_was_exact(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.scaling_was_exact)
}

// int64 integer_offset = 7;
inline void CpObjectiveProto::clear_integer_offset() {
  integer_offset_ = int64_t{0};
}
inline int64_t CpObjectiveProto::_internal_integer_offset() const {
  return integer_offset_;
}
inline int64_t CpObjectiveProto::integer_offset() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.integer_offset)
  return _internal_integer_offset();
}
inline void CpObjectiveProto::_internal_set_integer_offset(int64_t value) {
  
  integer_offset_ = value;
}
inline void CpObjectiveProto::set_integer_offset(int64_t value) {
  _internal_set_integer_offset(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.integer_offset)
}

// int64 integer_scaling_factor = 8;
inline void CpObjectiveProto::clear_integer_scaling_factor() {
  integer_scaling_factor_ = int64_t{0};
}
inline int64_t CpObjectiveProto::_internal_integer_scaling_factor() const {
  return integer_scaling_factor_;
}
inline int64_t CpObjectiveProto::integer_scaling_factor() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpObjectiveProto.integer_scaling_factor)
  return _internal_integer_scaling_factor();
}
inline void CpObjectiveProto::_internal_set_integer_scaling_factor(int64_t value) {
  
  integer_scaling_factor_ = value;
}
inline void CpObjectiveProto::set_integer_scaling_factor(int64_t value) {
  _internal_set_integer_scaling_factor(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpObjectiveProto.integer_scaling_factor)
}

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

// FloatObjectiveProto

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

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

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

// bool maximize = 4;
inline void FloatObjectiveProto::clear_maximize() {
  maximize_ = false;
}
inline bool FloatObjectiveProto::_internal_maximize() const {
  return maximize_;
}
inline bool FloatObjectiveProto::maximize() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.FloatObjectiveProto.maximize)
  return _internal_maximize();
}
inline void FloatObjectiveProto::_internal_set_maximize(bool value) {
  
  maximize_ = value;
}
inline void FloatObjectiveProto::set_maximize(bool value) {
  _internal_set_maximize(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.FloatObjectiveProto.maximize)
}

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

// DecisionStrategyProto_AffineTransformation

// int32 index = 1;
inline void DecisionStrategyProto_AffineTransformation::clear_index() {
  index_ = 0;
}
inline int32_t DecisionStrategyProto_AffineTransformation::_internal_index() const {
  return index_;
}
inline int32_t DecisionStrategyProto_AffineTransformation::index() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.AffineTransformation.index)
  return _internal_index();
}
inline void DecisionStrategyProto_AffineTransformation::_internal_set_index(int32_t value) {
  
  index_ = value;
}
inline void DecisionStrategyProto_AffineTransformation::set_index(int32_t value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.AffineTransformation.index)
}

// int64 offset = 2;
inline void DecisionStrategyProto_AffineTransformation::clear_offset() {
  offset_ = int64_t{0};
}
inline int64_t DecisionStrategyProto_AffineTransformation::_internal_offset() const {
  return offset_;
}
inline int64_t DecisionStrategyProto_AffineTransformation::offset() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.AffineTransformation.offset)
  return _internal_offset();
}
inline void DecisionStrategyProto_AffineTransformation::_internal_set_offset(int64_t value) {
  
  offset_ = value;
}
inline void DecisionStrategyProto_AffineTransformation::set_offset(int64_t value) {
  _internal_set_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_ = int64_t{0};
}
inline int64_t DecisionStrategyProto_AffineTransformation::_internal_positive_coeff() const {
  return positive_coeff_;
}
inline int64_t DecisionStrategyProto_AffineTransformation::positive_coeff() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.AffineTransformation.positive_coeff)
  return _internal_positive_coeff();
}
inline void DecisionStrategyProto_AffineTransformation::_internal_set_positive_coeff(int64_t value) {
  
  positive_coeff_ = value;
}
inline void DecisionStrategyProto_AffineTransformation::set_positive_coeff(int64_t value) {
  _internal_set_positive_coeff(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.AffineTransformation.positive_coeff)
}

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

// DecisionStrategyProto

// repeated int32 variables = 1;
inline int DecisionStrategyProto::_internal_variables_size() const {
  return variables_.size();
}
inline int DecisionStrategyProto::variables_size() const {
  return _internal_variables_size();
}
inline void DecisionStrategyProto::clear_variables() {
  variables_.Clear();
}
inline int32_t DecisionStrategyProto::_internal_variables(int index) const {
  return variables_.Get(index);
}
inline int32_t DecisionStrategyProto::variables(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.variables)
  return _internal_variables(index);
}
inline void DecisionStrategyProto::set_variables(int index, int32_t value) {
  variables_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.DecisionStrategyProto.variables)
}
inline void DecisionStrategyProto::_internal_add_variables(int32_t value) {
  variables_.Add(value);
}
inline void DecisionStrategyProto::add_variables(int32_t value) {
  _internal_add_variables(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.DecisionStrategyProto.variables)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DecisionStrategyProto::_internal_variables() const {
  return variables_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DecisionStrategyProto::variables() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.DecisionStrategyProto.variables)
  return _internal_variables();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DecisionStrategyProto::_internal_mutable_variables() {
  return &variables_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DecisionStrategyProto::mutable_variables() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.DecisionStrategyProto.variables)
  return _internal_mutable_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::_internal_variable_selection_strategy() const {
  return static_cast< ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy >(variable_selection_strategy_);
}
inline ::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy DecisionStrategyProto::variable_selection_strategy() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.variable_selection_strategy)
  return _internal_variable_selection_strategy();
}
inline void DecisionStrategyProto::_internal_set_variable_selection_strategy(::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy value) {
  
  variable_selection_strategy_ = value;
}
inline void DecisionStrategyProto::set_variable_selection_strategy(::operations_research::sat::DecisionStrategyProto_VariableSelectionStrategy value) {
  _internal_set_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::_internal_domain_reduction_strategy() const {
  return static_cast< ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy >(domain_reduction_strategy_);
}
inline ::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy DecisionStrategyProto::domain_reduction_strategy() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.domain_reduction_strategy)
  return _internal_domain_reduction_strategy();
}
inline void DecisionStrategyProto::_internal_set_domain_reduction_strategy(::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy value) {
  
  domain_reduction_strategy_ = value;
}
inline void DecisionStrategyProto::set_domain_reduction_strategy(::operations_research::sat::DecisionStrategyProto_DomainReductionStrategy value) {
  _internal_set_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::_internal_transformations_size() const {
  return transformations_.size();
}
inline int DecisionStrategyProto::transformations_size() const {
  return _internal_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 ::PROTOBUF_NAMESPACE_ID::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::_internal_transformations(int index) const {
  return transformations_.Get(index);
}
inline const ::operations_research::sat::DecisionStrategyProto_AffineTransformation& DecisionStrategyProto::transformations(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DecisionStrategyProto.transformations)
  return _internal_transformations(index);
}
inline ::operations_research::sat::DecisionStrategyProto_AffineTransformation* DecisionStrategyProto::_internal_add_transformations() {
  return transformations_.Add();
}
inline ::operations_research::sat::DecisionStrategyProto_AffineTransformation* DecisionStrategyProto::add_transformations() {
  ::operations_research::sat::DecisionStrategyProto_AffineTransformation* _add = _internal_add_transformations();
  // @@protoc_insertion_point(field_add:operations_research.sat.DecisionStrategyProto.transformations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_vars_size() const {
  return vars_.size();
}
inline int PartialVariableAssignment::vars_size() const {
  return _internal_vars_size();
}
inline void PartialVariableAssignment::clear_vars() {
  vars_.Clear();
}
inline int32_t PartialVariableAssignment::_internal_vars(int index) const {
  return vars_.Get(index);
}
inline int32_t PartialVariableAssignment::vars(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.PartialVariableAssignment.vars)
  return _internal_vars(index);
}
inline void PartialVariableAssignment::set_vars(int index, int32_t value) {
  vars_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.PartialVariableAssignment.vars)
}
inline void PartialVariableAssignment::_internal_add_vars(int32_t value) {
  vars_.Add(value);
}
inline void PartialVariableAssignment::add_vars(int32_t value) {
  _internal_add_vars(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.PartialVariableAssignment.vars)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
PartialVariableAssignment::_internal_vars() const {
  return vars_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
PartialVariableAssignment::vars() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.PartialVariableAssignment.vars)
  return _internal_vars();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
PartialVariableAssignment::_internal_mutable_vars() {
  return &vars_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
PartialVariableAssignment::mutable_vars() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.PartialVariableAssignment.vars)
  return _internal_mutable_vars();
}

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

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

// SparsePermutationProto

// repeated int32 support = 1;
inline int SparsePermutationProto::_internal_support_size() const {
  return support_.size();
}
inline int SparsePermutationProto::support_size() const {
  return _internal_support_size();
}
inline void SparsePermutationProto::clear_support() {
  support_.Clear();
}
inline int32_t SparsePermutationProto::_internal_support(int index) const {
  return support_.Get(index);
}
inline int32_t SparsePermutationProto::support(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SparsePermutationProto.support)
  return _internal_support(index);
}
inline void SparsePermutationProto::set_support(int index, int32_t value) {
  support_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SparsePermutationProto.support)
}
inline void SparsePermutationProto::_internal_add_support(int32_t value) {
  support_.Add(value);
}
inline void SparsePermutationProto::add_support(int32_t value) {
  _internal_add_support(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.SparsePermutationProto.support)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SparsePermutationProto::_internal_support() const {
  return support_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SparsePermutationProto::support() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.SparsePermutationProto.support)
  return _internal_support();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SparsePermutationProto::_internal_mutable_support() {
  return &support_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SparsePermutationProto::mutable_support() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SparsePermutationProto.support)
  return _internal_mutable_support();
}

// repeated int32 cycle_sizes = 2;
inline int SparsePermutationProto::_internal_cycle_sizes_size() const {
  return cycle_sizes_.size();
}
inline int SparsePermutationProto::cycle_sizes_size() const {
  return _internal_cycle_sizes_size();
}
inline void SparsePermutationProto::clear_cycle_sizes() {
  cycle_sizes_.Clear();
}
inline int32_t SparsePermutationProto::_internal_cycle_sizes(int index) const {
  return cycle_sizes_.Get(index);
}
inline int32_t SparsePermutationProto::cycle_sizes(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SparsePermutationProto.cycle_sizes)
  return _internal_cycle_sizes(index);
}
inline void SparsePermutationProto::set_cycle_sizes(int index, int32_t value) {
  cycle_sizes_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SparsePermutationProto.cycle_sizes)
}
inline void SparsePermutationProto::_internal_add_cycle_sizes(int32_t value) {
  cycle_sizes_.Add(value);
}
inline void SparsePermutationProto::add_cycle_sizes(int32_t value) {
  _internal_add_cycle_sizes(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.SparsePermutationProto.cycle_sizes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SparsePermutationProto::_internal_cycle_sizes() const {
  return cycle_sizes_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
SparsePermutationProto::cycle_sizes() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.SparsePermutationProto.cycle_sizes)
  return _internal_cycle_sizes();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SparsePermutationProto::_internal_mutable_cycle_sizes() {
  return &cycle_sizes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
SparsePermutationProto::mutable_cycle_sizes() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SparsePermutationProto.cycle_sizes)
  return _internal_mutable_cycle_sizes();
}

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

// DenseMatrixProto

// int32 num_rows = 1;
inline void DenseMatrixProto::clear_num_rows() {
  num_rows_ = 0;
}
inline int32_t DenseMatrixProto::_internal_num_rows() const {
  return num_rows_;
}
inline int32_t DenseMatrixProto::num_rows() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DenseMatrixProto.num_rows)
  return _internal_num_rows();
}
inline void DenseMatrixProto::_internal_set_num_rows(int32_t value) {
  
  num_rows_ = value;
}
inline void DenseMatrixProto::set_num_rows(int32_t value) {
  _internal_set_num_rows(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.DenseMatrixProto.num_rows)
}

// int32 num_cols = 2;
inline void DenseMatrixProto::clear_num_cols() {
  num_cols_ = 0;
}
inline int32_t DenseMatrixProto::_internal_num_cols() const {
  return num_cols_;
}
inline int32_t DenseMatrixProto::num_cols() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DenseMatrixProto.num_cols)
  return _internal_num_cols();
}
inline void DenseMatrixProto::_internal_set_num_cols(int32_t value) {
  
  num_cols_ = value;
}
inline void DenseMatrixProto::set_num_cols(int32_t value) {
  _internal_set_num_cols(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.DenseMatrixProto.num_cols)
}

// repeated int32 entries = 3;
inline int DenseMatrixProto::_internal_entries_size() const {
  return entries_.size();
}
inline int DenseMatrixProto::entries_size() const {
  return _internal_entries_size();
}
inline void DenseMatrixProto::clear_entries() {
  entries_.Clear();
}
inline int32_t DenseMatrixProto::_internal_entries(int index) const {
  return entries_.Get(index);
}
inline int32_t DenseMatrixProto::entries(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.DenseMatrixProto.entries)
  return _internal_entries(index);
}
inline void DenseMatrixProto::set_entries(int index, int32_t value) {
  entries_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.DenseMatrixProto.entries)
}
inline void DenseMatrixProto::_internal_add_entries(int32_t value) {
  entries_.Add(value);
}
inline void DenseMatrixProto::add_entries(int32_t value) {
  _internal_add_entries(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.DenseMatrixProto.entries)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseMatrixProto::_internal_entries() const {
  return entries_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
DenseMatrixProto::entries() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.DenseMatrixProto.entries)
  return _internal_entries();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseMatrixProto::_internal_mutable_entries() {
  return &entries_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
DenseMatrixProto::mutable_entries() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.DenseMatrixProto.entries)
  return _internal_mutable_entries();
}

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

// SymmetryProto

// repeated .operations_research.sat.SparsePermutationProto permutations = 1;
inline int SymmetryProto::_internal_permutations_size() const {
  return permutations_.size();
}
inline int SymmetryProto::permutations_size() const {
  return _internal_permutations_size();
}
inline void SymmetryProto::clear_permutations() {
  permutations_.Clear();
}
inline ::operations_research::sat::SparsePermutationProto* SymmetryProto::mutable_permutations(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SymmetryProto.permutations)
  return permutations_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::SparsePermutationProto >*
SymmetryProto::mutable_permutations() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SymmetryProto.permutations)
  return &permutations_;
}
inline const ::operations_research::sat::SparsePermutationProto& SymmetryProto::_internal_permutations(int index) const {
  return permutations_.Get(index);
}
inline const ::operations_research::sat::SparsePermutationProto& SymmetryProto::permutations(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SymmetryProto.permutations)
  return _internal_permutations(index);
}
inline ::operations_research::sat::SparsePermutationProto* SymmetryProto::_internal_add_permutations() {
  return permutations_.Add();
}
inline ::operations_research::sat::SparsePermutationProto* SymmetryProto::add_permutations() {
  ::operations_research::sat::SparsePermutationProto* _add = _internal_add_permutations();
  // @@protoc_insertion_point(field_add:operations_research.sat.SymmetryProto.permutations)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::SparsePermutationProto >&
SymmetryProto::permutations() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.SymmetryProto.permutations)
  return permutations_;
}

// repeated .operations_research.sat.DenseMatrixProto orbitopes = 2;
inline int SymmetryProto::_internal_orbitopes_size() const {
  return orbitopes_.size();
}
inline int SymmetryProto::orbitopes_size() const {
  return _internal_orbitopes_size();
}
inline void SymmetryProto::clear_orbitopes() {
  orbitopes_.Clear();
}
inline ::operations_research::sat::DenseMatrixProto* SymmetryProto::mutable_orbitopes(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SymmetryProto.orbitopes)
  return orbitopes_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DenseMatrixProto >*
SymmetryProto::mutable_orbitopes() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SymmetryProto.orbitopes)
  return &orbitopes_;
}
inline const ::operations_research::sat::DenseMatrixProto& SymmetryProto::_internal_orbitopes(int index) const {
  return orbitopes_.Get(index);
}
inline const ::operations_research::sat::DenseMatrixProto& SymmetryProto::orbitopes(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SymmetryProto.orbitopes)
  return _internal_orbitopes(index);
}
inline ::operations_research::sat::DenseMatrixProto* SymmetryProto::_internal_add_orbitopes() {
  return orbitopes_.Add();
}
inline ::operations_research::sat::DenseMatrixProto* SymmetryProto::add_orbitopes() {
  ::operations_research::sat::DenseMatrixProto* _add = _internal_add_orbitopes();
  // @@protoc_insertion_point(field_add:operations_research.sat.SymmetryProto.orbitopes)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::DenseMatrixProto >&
SymmetryProto::orbitopes() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.SymmetryProto.orbitopes)
  return orbitopes_;
}

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

// CpModelProto

// string name = 1;
inline void CpModelProto::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& CpModelProto::name() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CpModelProto::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.sat.CpModelProto.name)
}
inline std::string* CpModelProto::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.name)
  return _s;
}
inline const std::string& CpModelProto::_internal_name() const {
  return name_.Get();
}
inline void CpModelProto::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CpModelProto::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CpModelProto::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpModelProto.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CpModelProto::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpModelProto.name)
}

// repeated .operations_research.sat.IntegerVariableProto variables = 2;
inline int CpModelProto::_internal_variables_size() const {
  return variables_.size();
}
inline int CpModelProto::variables_size() const {
  return _internal_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 ::PROTOBUF_NAMESPACE_ID::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::_internal_variables(int index) const {
  return variables_.Get(index);
}
inline const ::operations_research::sat::IntegerVariableProto& CpModelProto::variables(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.variables)
  return _internal_variables(index);
}
inline ::operations_research::sat::IntegerVariableProto* CpModelProto::_internal_add_variables() {
  return variables_.Add();
}
inline ::operations_research::sat::IntegerVariableProto* CpModelProto::add_variables() {
  ::operations_research::sat::IntegerVariableProto* _add = _internal_add_variables();
  // @@protoc_insertion_point(field_add:operations_research.sat.CpModelProto.variables)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_constraints_size() const {
  return constraints_.size();
}
inline int CpModelProto::constraints_size() const {
  return _internal_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 ::PROTOBUF_NAMESPACE_ID::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::_internal_constraints(int index) const {
  return constraints_.Get(index);
}
inline const ::operations_research::sat::ConstraintProto& CpModelProto::constraints(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.constraints)
  return _internal_constraints(index);
}
inline ::operations_research::sat::ConstraintProto* CpModelProto::_internal_add_constraints() {
  return constraints_.Add();
}
inline ::operations_research::sat::ConstraintProto* CpModelProto::add_constraints() {
  ::operations_research::sat::ConstraintProto* _add = _internal_add_constraints();
  // @@protoc_insertion_point(field_add:operations_research.sat.CpModelProto.constraints)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_has_objective() const {
  return this != internal_default_instance() && objective_ != nullptr;
}
inline bool CpModelProto::has_objective() const {
  return _internal_has_objective();
}
inline void CpModelProto::clear_objective() {
  if (GetArenaForAllocation() == nullptr && objective_ != nullptr) {
    delete objective_;
  }
  objective_ = nullptr;
}
inline const ::operations_research::sat::CpObjectiveProto& CpModelProto::_internal_objective() const {
  const ::operations_research::sat::CpObjectiveProto* p = objective_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::CpObjectiveProto&>(
      ::operations_research::sat::_CpObjectiveProto_default_instance_);
}
inline const ::operations_research::sat::CpObjectiveProto& CpModelProto::objective() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.objective)
  return _internal_objective();
}
inline void CpModelProto::unsafe_arena_set_allocated_objective(
    ::operations_research::sat::CpObjectiveProto* objective) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(objective_);
  }
  objective_ = objective;
  if (objective) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.CpModelProto.objective)
}
inline ::operations_research::sat::CpObjectiveProto* CpModelProto::release_objective() {
  
  ::operations_research::sat::CpObjectiveProto* temp = objective_;
  objective_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::CpObjectiveProto* CpModelProto::unsafe_arena_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::_internal_mutable_objective() {
  
  if (objective_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::CpObjectiveProto>(GetArenaForAllocation());
    objective_ = p;
  }
  return objective_;
}
inline ::operations_research::sat::CpObjectiveProto* CpModelProto::mutable_objective() {
  ::operations_research::sat::CpObjectiveProto* _msg = _internal_mutable_objective();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.objective)
  return _msg;
}
inline void CpModelProto::set_allocated_objective(::operations_research::sat::CpObjectiveProto* objective) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete objective_;
  }
  if (objective) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::CpObjectiveProto>::GetOwningArena(objective);
    if (message_arena != submessage_arena) {
      objective = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, objective, submessage_arena);
    }
    
  } else {
    
  }
  objective_ = objective;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpModelProto.objective)
}

// .operations_research.sat.FloatObjectiveProto floating_point_objective = 9;
inline bool CpModelProto::_internal_has_floating_point_objective() const {
  return this != internal_default_instance() && floating_point_objective_ != nullptr;
}
inline bool CpModelProto::has_floating_point_objective() const {
  return _internal_has_floating_point_objective();
}
inline void CpModelProto::clear_floating_point_objective() {
  if (GetArenaForAllocation() == nullptr && floating_point_objective_ != nullptr) {
    delete floating_point_objective_;
  }
  floating_point_objective_ = nullptr;
}
inline const ::operations_research::sat::FloatObjectiveProto& CpModelProto::_internal_floating_point_objective() const {
  const ::operations_research::sat::FloatObjectiveProto* p = floating_point_objective_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::FloatObjectiveProto&>(
      ::operations_research::sat::_FloatObjectiveProto_default_instance_);
}
inline const ::operations_research::sat::FloatObjectiveProto& CpModelProto::floating_point_objective() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.floating_point_objective)
  return _internal_floating_point_objective();
}
inline void CpModelProto::unsafe_arena_set_allocated_floating_point_objective(
    ::operations_research::sat::FloatObjectiveProto* floating_point_objective) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(floating_point_objective_);
  }
  floating_point_objective_ = floating_point_objective;
  if (floating_point_objective) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.CpModelProto.floating_point_objective)
}
inline ::operations_research::sat::FloatObjectiveProto* CpModelProto::release_floating_point_objective() {
  
  ::operations_research::sat::FloatObjectiveProto* temp = floating_point_objective_;
  floating_point_objective_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::FloatObjectiveProto* CpModelProto::unsafe_arena_release_floating_point_objective() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpModelProto.floating_point_objective)
  
  ::operations_research::sat::FloatObjectiveProto* temp = floating_point_objective_;
  floating_point_objective_ = nullptr;
  return temp;
}
inline ::operations_research::sat::FloatObjectiveProto* CpModelProto::_internal_mutable_floating_point_objective() {
  
  if (floating_point_objective_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::FloatObjectiveProto>(GetArenaForAllocation());
    floating_point_objective_ = p;
  }
  return floating_point_objective_;
}
inline ::operations_research::sat::FloatObjectiveProto* CpModelProto::mutable_floating_point_objective() {
  ::operations_research::sat::FloatObjectiveProto* _msg = _internal_mutable_floating_point_objective();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.floating_point_objective)
  return _msg;
}
inline void CpModelProto::set_allocated_floating_point_objective(::operations_research::sat::FloatObjectiveProto* floating_point_objective) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete floating_point_objective_;
  }
  if (floating_point_objective) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::FloatObjectiveProto>::GetOwningArena(floating_point_objective);
    if (message_arena != submessage_arena) {
      floating_point_objective = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, floating_point_objective, submessage_arena);
    }
    
  } else {
    
  }
  floating_point_objective_ = floating_point_objective;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpModelProto.floating_point_objective)
}

// repeated .operations_research.sat.DecisionStrategyProto search_strategy = 5;
inline int CpModelProto::_internal_search_strategy_size() const {
  return search_strategy_.size();
}
inline int CpModelProto::search_strategy_size() const {
  return _internal_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 ::PROTOBUF_NAMESPACE_ID::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::_internal_search_strategy(int index) const {
  return search_strategy_.Get(index);
}
inline const ::operations_research::sat::DecisionStrategyProto& CpModelProto::search_strategy(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.search_strategy)
  return _internal_search_strategy(index);
}
inline ::operations_research::sat::DecisionStrategyProto* CpModelProto::_internal_add_search_strategy() {
  return search_strategy_.Add();
}
inline ::operations_research::sat::DecisionStrategyProto* CpModelProto::add_search_strategy() {
  ::operations_research::sat::DecisionStrategyProto* _add = _internal_add_search_strategy();
  // @@protoc_insertion_point(field_add:operations_research.sat.CpModelProto.search_strategy)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::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::_internal_has_solution_hint() const {
  return this != internal_default_instance() && solution_hint_ != nullptr;
}
inline bool CpModelProto::has_solution_hint() const {
  return _internal_has_solution_hint();
}
inline void CpModelProto::clear_solution_hint() {
  if (GetArenaForAllocation() == nullptr && solution_hint_ != nullptr) {
    delete solution_hint_;
  }
  solution_hint_ = nullptr;
}
inline const ::operations_research::sat::PartialVariableAssignment& CpModelProto::_internal_solution_hint() const {
  const ::operations_research::sat::PartialVariableAssignment* p = solution_hint_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::PartialVariableAssignment&>(
      ::operations_research::sat::_PartialVariableAssignment_default_instance_);
}
inline const ::operations_research::sat::PartialVariableAssignment& CpModelProto::solution_hint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.solution_hint)
  return _internal_solution_hint();
}
inline void CpModelProto::unsafe_arena_set_allocated_solution_hint(
    ::operations_research::sat::PartialVariableAssignment* solution_hint) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(solution_hint_);
  }
  solution_hint_ = solution_hint;
  if (solution_hint) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.CpModelProto.solution_hint)
}
inline ::operations_research::sat::PartialVariableAssignment* CpModelProto::release_solution_hint() {
  
  ::operations_research::sat::PartialVariableAssignment* temp = solution_hint_;
  solution_hint_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::PartialVariableAssignment* CpModelProto::unsafe_arena_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::_internal_mutable_solution_hint() {
  
  if (solution_hint_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::PartialVariableAssignment>(GetArenaForAllocation());
    solution_hint_ = p;
  }
  return solution_hint_;
}
inline ::operations_research::sat::PartialVariableAssignment* CpModelProto::mutable_solution_hint() {
  ::operations_research::sat::PartialVariableAssignment* _msg = _internal_mutable_solution_hint();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.solution_hint)
  return _msg;
}
inline void CpModelProto::set_allocated_solution_hint(::operations_research::sat::PartialVariableAssignment* solution_hint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete solution_hint_;
  }
  if (solution_hint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::PartialVariableAssignment>::GetOwningArena(solution_hint);
    if (message_arena != submessage_arena) {
      solution_hint = ::PROTOBUF_NAMESPACE_ID::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)
}

// repeated int32 assumptions = 7;
inline int CpModelProto::_internal_assumptions_size() const {
  return assumptions_.size();
}
inline int CpModelProto::assumptions_size() const {
  return _internal_assumptions_size();
}
inline void CpModelProto::clear_assumptions() {
  assumptions_.Clear();
}
inline int32_t CpModelProto::_internal_assumptions(int index) const {
  return assumptions_.Get(index);
}
inline int32_t CpModelProto::assumptions(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.assumptions)
  return _internal_assumptions(index);
}
inline void CpModelProto::set_assumptions(int index, int32_t value) {
  assumptions_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpModelProto.assumptions)
}
inline void CpModelProto::_internal_add_assumptions(int32_t value) {
  assumptions_.Add(value);
}
inline void CpModelProto::add_assumptions(int32_t value) {
  _internal_add_assumptions(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpModelProto.assumptions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CpModelProto::_internal_assumptions() const {
  return assumptions_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CpModelProto::assumptions() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpModelProto.assumptions)
  return _internal_assumptions();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CpModelProto::_internal_mutable_assumptions() {
  return &assumptions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CpModelProto::mutable_assumptions() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpModelProto.assumptions)
  return _internal_mutable_assumptions();
}

// .operations_research.sat.SymmetryProto symmetry = 8;
inline bool CpModelProto::_internal_has_symmetry() const {
  return this != internal_default_instance() && symmetry_ != nullptr;
}
inline bool CpModelProto::has_symmetry() const {
  return _internal_has_symmetry();
}
inline void CpModelProto::clear_symmetry() {
  if (GetArenaForAllocation() == nullptr && symmetry_ != nullptr) {
    delete symmetry_;
  }
  symmetry_ = nullptr;
}
inline const ::operations_research::sat::SymmetryProto& CpModelProto::_internal_symmetry() const {
  const ::operations_research::sat::SymmetryProto* p = symmetry_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::SymmetryProto&>(
      ::operations_research::sat::_SymmetryProto_default_instance_);
}
inline const ::operations_research::sat::SymmetryProto& CpModelProto::symmetry() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpModelProto.symmetry)
  return _internal_symmetry();
}
inline void CpModelProto::unsafe_arena_set_allocated_symmetry(
    ::operations_research::sat::SymmetryProto* symmetry) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(symmetry_);
  }
  symmetry_ = symmetry;
  if (symmetry) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.CpModelProto.symmetry)
}
inline ::operations_research::sat::SymmetryProto* CpModelProto::release_symmetry() {
  
  ::operations_research::sat::SymmetryProto* temp = symmetry_;
  symmetry_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::SymmetryProto* CpModelProto::unsafe_arena_release_symmetry() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpModelProto.symmetry)
  
  ::operations_research::sat::SymmetryProto* temp = symmetry_;
  symmetry_ = nullptr;
  return temp;
}
inline ::operations_research::sat::SymmetryProto* CpModelProto::_internal_mutable_symmetry() {
  
  if (symmetry_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::SymmetryProto>(GetArenaForAllocation());
    symmetry_ = p;
  }
  return symmetry_;
}
inline ::operations_research::sat::SymmetryProto* CpModelProto::mutable_symmetry() {
  ::operations_research::sat::SymmetryProto* _msg = _internal_mutable_symmetry();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpModelProto.symmetry)
  return _msg;
}
inline void CpModelProto::set_allocated_symmetry(::operations_research::sat::SymmetryProto* symmetry) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete symmetry_;
  }
  if (symmetry) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::SymmetryProto>::GetOwningArena(symmetry);
    if (message_arena != submessage_arena) {
      symmetry = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, symmetry, submessage_arena);
    }
    
  } else {
    
  }
  symmetry_ = symmetry;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpModelProto.symmetry)
}

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

// CpSolverSolution

// repeated int64 values = 1;
inline int CpSolverSolution::_internal_values_size() const {
  return values_.size();
}
inline int CpSolverSolution::values_size() const {
  return _internal_values_size();
}
inline void CpSolverSolution::clear_values() {
  values_.Clear();
}
inline int64_t CpSolverSolution::_internal_values(int index) const {
  return values_.Get(index);
}
inline int64_t CpSolverSolution::values(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverSolution.values)
  return _internal_values(index);
}
inline void CpSolverSolution::set_values(int index, int64_t value) {
  values_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverSolution.values)
}
inline void CpSolverSolution::_internal_add_values(int64_t value) {
  values_.Add(value);
}
inline void CpSolverSolution::add_values(int64_t value) {
  _internal_add_values(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpSolverSolution.values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
CpSolverSolution::_internal_values() const {
  return values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >&
CpSolverSolution::values() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpSolverSolution.values)
  return _internal_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
CpSolverSolution::_internal_mutable_values() {
  return &values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >*
CpSolverSolution::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpSolverSolution.values)
  return _internal_mutable_values();
}

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

// CpSolverResponse

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

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

// double objective_value = 3;
inline void CpSolverResponse::clear_objective_value() {
  objective_value_ = 0;
}
inline double CpSolverResponse::_internal_objective_value() const {
  return objective_value_;
}
inline double CpSolverResponse::objective_value() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.objective_value)
  return _internal_objective_value();
}
inline void CpSolverResponse::_internal_set_objective_value(double value) {
  
  objective_value_ = value;
}
inline void CpSolverResponse::set_objective_value(double value) {
  _internal_set_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::_internal_best_objective_bound() const {
  return best_objective_bound_;
}
inline double CpSolverResponse::best_objective_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.best_objective_bound)
  return _internal_best_objective_bound();
}
inline void CpSolverResponse::_internal_set_best_objective_bound(double value) {
  
  best_objective_bound_ = value;
}
inline void CpSolverResponse::set_best_objective_bound(double value) {
  _internal_set_best_objective_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.best_objective_bound)
}

// repeated .operations_research.sat.CpSolverSolution additional_solutions = 27;
inline int CpSolverResponse::_internal_additional_solutions_size() const {
  return additional_solutions_.size();
}
inline int CpSolverResponse::additional_solutions_size() const {
  return _internal_additional_solutions_size();
}
inline void CpSolverResponse::clear_additional_solutions() {
  additional_solutions_.Clear();
}
inline ::operations_research::sat::CpSolverSolution* CpSolverResponse::mutable_additional_solutions(int index) {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpSolverResponse.additional_solutions)
  return additional_solutions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::CpSolverSolution >*
CpSolverResponse::mutable_additional_solutions() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpSolverResponse.additional_solutions)
  return &additional_solutions_;
}
inline const ::operations_research::sat::CpSolverSolution& CpSolverResponse::_internal_additional_solutions(int index) const {
  return additional_solutions_.Get(index);
}
inline const ::operations_research::sat::CpSolverSolution& CpSolverResponse::additional_solutions(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.additional_solutions)
  return _internal_additional_solutions(index);
}
inline ::operations_research::sat::CpSolverSolution* CpSolverResponse::_internal_add_additional_solutions() {
  return additional_solutions_.Add();
}
inline ::operations_research::sat::CpSolverSolution* CpSolverResponse::add_additional_solutions() {
  ::operations_research::sat::CpSolverSolution* _add = _internal_add_additional_solutions();
  // @@protoc_insertion_point(field_add:operations_research.sat.CpSolverResponse.additional_solutions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::CpSolverSolution >&
CpSolverResponse::additional_solutions() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpSolverResponse.additional_solutions)
  return additional_solutions_;
}

// repeated .operations_research.sat.IntegerVariableProto tightened_variables = 21;
inline int CpSolverResponse::_internal_tightened_variables_size() const {
  return tightened_variables_.size();
}
inline int CpSolverResponse::tightened_variables_size() const {
  return _internal_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 ::PROTOBUF_NAMESPACE_ID::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::_internal_tightened_variables(int index) const {
  return tightened_variables_.Get(index);
}
inline const ::operations_research::sat::IntegerVariableProto& CpSolverResponse::tightened_variables(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.tightened_variables)
  return _internal_tightened_variables(index);
}
inline ::operations_research::sat::IntegerVariableProto* CpSolverResponse::_internal_add_tightened_variables() {
  return tightened_variables_.Add();
}
inline ::operations_research::sat::IntegerVariableProto* CpSolverResponse::add_tightened_variables() {
  ::operations_research::sat::IntegerVariableProto* _add = _internal_add_tightened_variables();
  // @@protoc_insertion_point(field_add:operations_research.sat.CpSolverResponse.tightened_variables)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::operations_research::sat::IntegerVariableProto >&
CpSolverResponse::tightened_variables() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpSolverResponse.tightened_variables)
  return tightened_variables_;
}

// repeated int32 sufficient_assumptions_for_infeasibility = 23;
inline int CpSolverResponse::_internal_sufficient_assumptions_for_infeasibility_size() const {
  return sufficient_assumptions_for_infeasibility_.size();
}
inline int CpSolverResponse::sufficient_assumptions_for_infeasibility_size() const {
  return _internal_sufficient_assumptions_for_infeasibility_size();
}
inline void CpSolverResponse::clear_sufficient_assumptions_for_infeasibility() {
  sufficient_assumptions_for_infeasibility_.Clear();
}
inline int32_t CpSolverResponse::_internal_sufficient_assumptions_for_infeasibility(int index) const {
  return sufficient_assumptions_for_infeasibility_.Get(index);
}
inline int32_t CpSolverResponse::sufficient_assumptions_for_infeasibility(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.sufficient_assumptions_for_infeasibility)
  return _internal_sufficient_assumptions_for_infeasibility(index);
}
inline void CpSolverResponse::set_sufficient_assumptions_for_infeasibility(int index, int32_t value) {
  sufficient_assumptions_for_infeasibility_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.sufficient_assumptions_for_infeasibility)
}
inline void CpSolverResponse::_internal_add_sufficient_assumptions_for_infeasibility(int32_t value) {
  sufficient_assumptions_for_infeasibility_.Add(value);
}
inline void CpSolverResponse::add_sufficient_assumptions_for_infeasibility(int32_t value) {
  _internal_add_sufficient_assumptions_for_infeasibility(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.CpSolverResponse.sufficient_assumptions_for_infeasibility)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CpSolverResponse::_internal_sufficient_assumptions_for_infeasibility() const {
  return sufficient_assumptions_for_infeasibility_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
CpSolverResponse::sufficient_assumptions_for_infeasibility() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.CpSolverResponse.sufficient_assumptions_for_infeasibility)
  return _internal_sufficient_assumptions_for_infeasibility();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CpSolverResponse::_internal_mutable_sufficient_assumptions_for_infeasibility() {
  return &sufficient_assumptions_for_infeasibility_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
CpSolverResponse::mutable_sufficient_assumptions_for_infeasibility() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.CpSolverResponse.sufficient_assumptions_for_infeasibility)
  return _internal_mutable_sufficient_assumptions_for_infeasibility();
}

// .operations_research.sat.CpObjectiveProto integer_objective = 28;
inline bool CpSolverResponse::_internal_has_integer_objective() const {
  return this != internal_default_instance() && integer_objective_ != nullptr;
}
inline bool CpSolverResponse::has_integer_objective() const {
  return _internal_has_integer_objective();
}
inline void CpSolverResponse::clear_integer_objective() {
  if (GetArenaForAllocation() == nullptr && integer_objective_ != nullptr) {
    delete integer_objective_;
  }
  integer_objective_ = nullptr;
}
inline const ::operations_research::sat::CpObjectiveProto& CpSolverResponse::_internal_integer_objective() const {
  const ::operations_research::sat::CpObjectiveProto* p = integer_objective_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::CpObjectiveProto&>(
      ::operations_research::sat::_CpObjectiveProto_default_instance_);
}
inline const ::operations_research::sat::CpObjectiveProto& CpSolverResponse::integer_objective() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.integer_objective)
  return _internal_integer_objective();
}
inline void CpSolverResponse::unsafe_arena_set_allocated_integer_objective(
    ::operations_research::sat::CpObjectiveProto* integer_objective) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(integer_objective_);
  }
  integer_objective_ = integer_objective;
  if (integer_objective) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.CpSolverResponse.integer_objective)
}
inline ::operations_research::sat::CpObjectiveProto* CpSolverResponse::release_integer_objective() {
  
  ::operations_research::sat::CpObjectiveProto* temp = integer_objective_;
  integer_objective_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::operations_research::sat::CpObjectiveProto* CpSolverResponse::unsafe_arena_release_integer_objective() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpSolverResponse.integer_objective)
  
  ::operations_research::sat::CpObjectiveProto* temp = integer_objective_;
  integer_objective_ = nullptr;
  return temp;
}
inline ::operations_research::sat::CpObjectiveProto* CpSolverResponse::_internal_mutable_integer_objective() {
  
  if (integer_objective_ == nullptr) {
    auto* p = CreateMaybeMessage<::operations_research::sat::CpObjectiveProto>(GetArenaForAllocation());
    integer_objective_ = p;
  }
  return integer_objective_;
}
inline ::operations_research::sat::CpObjectiveProto* CpSolverResponse::mutable_integer_objective() {
  ::operations_research::sat::CpObjectiveProto* _msg = _internal_mutable_integer_objective();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpSolverResponse.integer_objective)
  return _msg;
}
inline void CpSolverResponse::set_allocated_integer_objective(::operations_research::sat::CpObjectiveProto* integer_objective) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete integer_objective_;
  }
  if (integer_objective) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::sat::CpObjectiveProto>::GetOwningArena(integer_objective);
    if (message_arena != submessage_arena) {
      integer_objective = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, integer_objective, submessage_arena);
    }
    
  } else {
    
  }
  integer_objective_ = integer_objective;
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpSolverResponse.integer_objective)
}

// int64 inner_objective_lower_bound = 29;
inline void CpSolverResponse::clear_inner_objective_lower_bound() {
  inner_objective_lower_bound_ = int64_t{0};
}
inline int64_t CpSolverResponse::_internal_inner_objective_lower_bound() const {
  return inner_objective_lower_bound_;
}
inline int64_t CpSolverResponse::inner_objective_lower_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.inner_objective_lower_bound)
  return _internal_inner_objective_lower_bound();
}
inline void CpSolverResponse::_internal_set_inner_objective_lower_bound(int64_t value) {
  
  inner_objective_lower_bound_ = value;
}
inline void CpSolverResponse::set_inner_objective_lower_bound(int64_t value) {
  _internal_set_inner_objective_lower_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.inner_objective_lower_bound)
}

// int64 num_booleans = 10;
inline void CpSolverResponse::clear_num_booleans() {
  num_booleans_ = int64_t{0};
}
inline int64_t CpSolverResponse::_internal_num_booleans() const {
  return num_booleans_;
}
inline int64_t CpSolverResponse::num_booleans() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_booleans)
  return _internal_num_booleans();
}
inline void CpSolverResponse::_internal_set_num_booleans(int64_t value) {
  
  num_booleans_ = value;
}
inline void CpSolverResponse::set_num_booleans(int64_t value) {
  _internal_set_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_ = int64_t{0};
}
inline int64_t CpSolverResponse::_internal_num_conflicts() const {
  return num_conflicts_;
}
inline int64_t CpSolverResponse::num_conflicts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_conflicts)
  return _internal_num_conflicts();
}
inline void CpSolverResponse::_internal_set_num_conflicts(int64_t value) {
  
  num_conflicts_ = value;
}
inline void CpSolverResponse::set_num_conflicts(int64_t value) {
  _internal_set_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_ = int64_t{0};
}
inline int64_t CpSolverResponse::_internal_num_branches() const {
  return num_branches_;
}
inline int64_t CpSolverResponse::num_branches() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_branches)
  return _internal_num_branches();
}
inline void CpSolverResponse::_internal_set_num_branches(int64_t value) {
  
  num_branches_ = value;
}
inline void CpSolverResponse::set_num_branches(int64_t value) {
  _internal_set_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_ = int64_t{0};
}
inline int64_t CpSolverResponse::_internal_num_binary_propagations() const {
  return num_binary_propagations_;
}
inline int64_t CpSolverResponse::num_binary_propagations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_binary_propagations)
  return _internal_num_binary_propagations();
}
inline void CpSolverResponse::_internal_set_num_binary_propagations(int64_t value) {
  
  num_binary_propagations_ = value;
}
inline void CpSolverResponse::set_num_binary_propagations(int64_t value) {
  _internal_set_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_ = int64_t{0};
}
inline int64_t CpSolverResponse::_internal_num_integer_propagations() const {
  return num_integer_propagations_;
}
inline int64_t CpSolverResponse::num_integer_propagations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_integer_propagations)
  return _internal_num_integer_propagations();
}
inline void CpSolverResponse::_internal_set_num_integer_propagations(int64_t value) {
  
  num_integer_propagations_ = value;
}
inline void CpSolverResponse::set_num_integer_propagations(int64_t value) {
  _internal_set_num_integer_propagations(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.num_integer_propagations)
}

// int64 num_restarts = 24;
inline void CpSolverResponse::clear_num_restarts() {
  num_restarts_ = int64_t{0};
}
inline int64_t CpSolverResponse::_internal_num_restarts() const {
  return num_restarts_;
}
inline int64_t CpSolverResponse::num_restarts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_restarts)
  return _internal_num_restarts();
}
inline void CpSolverResponse::_internal_set_num_restarts(int64_t value) {
  
  num_restarts_ = value;
}
inline void CpSolverResponse::set_num_restarts(int64_t value) {
  _internal_set_num_restarts(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.num_restarts)
}

// int64 num_lp_iterations = 25;
inline void CpSolverResponse::clear_num_lp_iterations() {
  num_lp_iterations_ = int64_t{0};
}
inline int64_t CpSolverResponse::_internal_num_lp_iterations() const {
  return num_lp_iterations_;
}
inline int64_t CpSolverResponse::num_lp_iterations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.num_lp_iterations)
  return _internal_num_lp_iterations();
}
inline void CpSolverResponse::_internal_set_num_lp_iterations(int64_t value) {
  
  num_lp_iterations_ = value;
}
inline void CpSolverResponse::set_num_lp_iterations(int64_t value) {
  _internal_set_num_lp_iterations(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.num_lp_iterations)
}

// double wall_time = 15;
inline void CpSolverResponse::clear_wall_time() {
  wall_time_ = 0;
}
inline double CpSolverResponse::_internal_wall_time() const {
  return wall_time_;
}
inline double CpSolverResponse::wall_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.wall_time)
  return _internal_wall_time();
}
inline void CpSolverResponse::_internal_set_wall_time(double value) {
  
  wall_time_ = value;
}
inline void CpSolverResponse::set_wall_time(double value) {
  _internal_set_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::_internal_user_time() const {
  return user_time_;
}
inline double CpSolverResponse::user_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.user_time)
  return _internal_user_time();
}
inline void CpSolverResponse::_internal_set_user_time(double value) {
  
  user_time_ = value;
}
inline void CpSolverResponse::set_user_time(double value) {
  _internal_set_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::_internal_deterministic_time() const {
  return deterministic_time_;
}
inline double CpSolverResponse::deterministic_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.deterministic_time)
  return _internal_deterministic_time();
}
inline void CpSolverResponse::_internal_set_deterministic_time(double value) {
  
  deterministic_time_ = value;
}
inline void CpSolverResponse::set_deterministic_time(double value) {
  _internal_set_deterministic_time(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.deterministic_time)
}

// double gap_integral = 22;
inline void CpSolverResponse::clear_gap_integral() {
  gap_integral_ = 0;
}
inline double CpSolverResponse::_internal_gap_integral() const {
  return gap_integral_;
}
inline double CpSolverResponse::gap_integral() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.gap_integral)
  return _internal_gap_integral();
}
inline void CpSolverResponse::_internal_set_gap_integral(double value) {
  
  gap_integral_ = value;
}
inline void CpSolverResponse::set_gap_integral(double value) {
  _internal_set_gap_integral(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.gap_integral)
}

// string solution_info = 20;
inline void CpSolverResponse::clear_solution_info() {
  solution_info_.ClearToEmpty();
}
inline const std::string& CpSolverResponse::solution_info() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.solution_info)
  return _internal_solution_info();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CpSolverResponse::set_solution_info(ArgT0&& arg0, ArgT... args) {
 
 solution_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.solution_info)
}
inline std::string* CpSolverResponse::mutable_solution_info() {
  std::string* _s = _internal_mutable_solution_info();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpSolverResponse.solution_info)
  return _s;
}
inline const std::string& CpSolverResponse::_internal_solution_info() const {
  return solution_info_.Get();
}
inline void CpSolverResponse::_internal_set_solution_info(const std::string& value) {
  
  solution_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CpSolverResponse::_internal_mutable_solution_info() {
  
  return solution_info_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CpSolverResponse::release_solution_info() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpSolverResponse.solution_info)
  return solution_info_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CpSolverResponse::set_allocated_solution_info(std::string* solution_info) {
  if (solution_info != nullptr) {
    
  } else {
    
  }
  solution_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), solution_info,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (solution_info_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    solution_info_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpSolverResponse.solution_info)
}

// string solve_log = 26;
inline void CpSolverResponse::clear_solve_log() {
  solve_log_.ClearToEmpty();
}
inline const std::string& CpSolverResponse::solve_log() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.CpSolverResponse.solve_log)
  return _internal_solve_log();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CpSolverResponse::set_solve_log(ArgT0&& arg0, ArgT... args) {
 
 solve_log_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.sat.CpSolverResponse.solve_log)
}
inline std::string* CpSolverResponse::mutable_solve_log() {
  std::string* _s = _internal_mutable_solve_log();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.CpSolverResponse.solve_log)
  return _s;
}
inline const std::string& CpSolverResponse::_internal_solve_log() const {
  return solve_log_.Get();
}
inline void CpSolverResponse::_internal_set_solve_log(const std::string& value) {
  
  solve_log_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CpSolverResponse::_internal_mutable_solve_log() {
  
  return solve_log_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CpSolverResponse::release_solve_log() {
  // @@protoc_insertion_point(field_release:operations_research.sat.CpSolverResponse.solve_log)
  return solve_log_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CpSolverResponse::set_allocated_solve_log(std::string* solve_log) {
  if (solve_log != nullptr) {
    
  } else {
    
  }
  solve_log_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), solve_log,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (solve_log_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    solve_log_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.CpSolverResponse.solve_log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace sat
}  // namespace operations_research

PROTOBUF_NAMESPACE_OPEN

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();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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