sat_parameters.pb.h

Go to the documentation of this file.

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3008000
#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 3008000 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/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_2fsat_5fparameters_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_2fsat_5fparameters_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
    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 ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto;
namespace operations_research {
namespace sat {
class SatParameters;
class SatParametersDefaultTypeInternal;
extern SatParametersDefaultTypeInternal _SatParameters_default_instance_;
}  // namespace sat
}  // namespace operations_research
PROTOBUF_NAMESPACE_OPEN
template<> ::operations_research::sat::SatParameters* Arena::CreateMaybeMessage<::operations_research::sat::SatParameters>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace operations_research {
namespace sat {

enum SatParameters_VariableOrder : int {
  SatParameters_VariableOrder_IN_ORDER = 0,
  SatParameters_VariableOrder_IN_REVERSE_ORDER = 1,
  SatParameters_VariableOrder_IN_RANDOM_ORDER = 2
};
bool SatParameters_VariableOrder_IsValid(int value);
constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MIN = SatParameters_VariableOrder_IN_ORDER;
constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MAX = SatParameters_VariableOrder_IN_RANDOM_ORDER;
constexpr int SatParameters_VariableOrder_VariableOrder_ARRAYSIZE = SatParameters_VariableOrder_VariableOrder_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_VariableOrder_descriptor();
template<typename T>
inline const std::string& SatParameters_VariableOrder_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_VariableOrder>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_VariableOrder_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_VariableOrder_descriptor(), enum_t_value);
}
inline bool SatParameters_VariableOrder_Parse(
    const std::string& name, SatParameters_VariableOrder* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_VariableOrder>(
    SatParameters_VariableOrder_descriptor(), name, value);
}
enum SatParameters_Polarity : int {
  SatParameters_Polarity_POLARITY_TRUE = 0,
  SatParameters_Polarity_POLARITY_FALSE = 1,
  SatParameters_Polarity_POLARITY_RANDOM = 2,
  SatParameters_Polarity_POLARITY_WEIGHTED_SIGN = 3,
  SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN = 4
};
bool SatParameters_Polarity_IsValid(int value);
constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MIN = SatParameters_Polarity_POLARITY_TRUE;
constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MAX = SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN;
constexpr int SatParameters_Polarity_Polarity_ARRAYSIZE = SatParameters_Polarity_Polarity_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_Polarity_descriptor();
template<typename T>
inline const std::string& SatParameters_Polarity_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_Polarity>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_Polarity_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_Polarity_descriptor(), enum_t_value);
}
inline bool SatParameters_Polarity_Parse(
    const std::string& name, SatParameters_Polarity* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_Polarity>(
    SatParameters_Polarity_descriptor(), name, value);
}
enum SatParameters_ConflictMinimizationAlgorithm : int {
  SatParameters_ConflictMinimizationAlgorithm_NONE = 0,
  SatParameters_ConflictMinimizationAlgorithm_SIMPLE = 1,
  SatParameters_ConflictMinimizationAlgorithm_RECURSIVE = 2,
  SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL = 3
};
bool SatParameters_ConflictMinimizationAlgorithm_IsValid(int value);
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN = SatParameters_ConflictMinimizationAlgorithm_NONE;
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX = SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL;
constexpr int SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE = SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ConflictMinimizationAlgorithm_descriptor();
template<typename T>
inline const std::string& SatParameters_ConflictMinimizationAlgorithm_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_ConflictMinimizationAlgorithm>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_ConflictMinimizationAlgorithm_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_ConflictMinimizationAlgorithm_descriptor(), enum_t_value);
}
inline bool SatParameters_ConflictMinimizationAlgorithm_Parse(
    const std::string& name, SatParameters_ConflictMinimizationAlgorithm* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ConflictMinimizationAlgorithm>(
    SatParameters_ConflictMinimizationAlgorithm_descriptor(), name, value);
}
enum SatParameters_BinaryMinizationAlgorithm : int {
  SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION = 0,
  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST = 1,
  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION = 4,
  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY = 2,
  SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION = 3
};
bool SatParameters_BinaryMinizationAlgorithm_IsValid(int value);
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN = SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION;
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX = SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION;
constexpr int SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE = SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_BinaryMinizationAlgorithm_descriptor();
template<typename T>
inline const std::string& SatParameters_BinaryMinizationAlgorithm_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_BinaryMinizationAlgorithm>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_BinaryMinizationAlgorithm_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_BinaryMinizationAlgorithm_descriptor(), enum_t_value);
}
inline bool SatParameters_BinaryMinizationAlgorithm_Parse(
    const std::string& name, SatParameters_BinaryMinizationAlgorithm* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_BinaryMinizationAlgorithm>(
    SatParameters_BinaryMinizationAlgorithm_descriptor(), name, value);
}
enum SatParameters_ClauseProtection : int {
  SatParameters_ClauseProtection_PROTECTION_NONE = 0,
  SatParameters_ClauseProtection_PROTECTION_ALWAYS = 1,
  SatParameters_ClauseProtection_PROTECTION_LBD = 2
};
bool SatParameters_ClauseProtection_IsValid(int value);
constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MIN = SatParameters_ClauseProtection_PROTECTION_NONE;
constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MAX = SatParameters_ClauseProtection_PROTECTION_LBD;
constexpr int SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE = SatParameters_ClauseProtection_ClauseProtection_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ClauseProtection_descriptor();
template<typename T>
inline const std::string& SatParameters_ClauseProtection_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_ClauseProtection>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_ClauseProtection_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_ClauseProtection_descriptor(), enum_t_value);
}
inline bool SatParameters_ClauseProtection_Parse(
    const std::string& name, SatParameters_ClauseProtection* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ClauseProtection>(
    SatParameters_ClauseProtection_descriptor(), name, value);
}
enum SatParameters_ClauseOrdering : int {
  SatParameters_ClauseOrdering_CLAUSE_ACTIVITY = 0,
  SatParameters_ClauseOrdering_CLAUSE_LBD = 1
};
bool SatParameters_ClauseOrdering_IsValid(int value);
constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MIN = SatParameters_ClauseOrdering_CLAUSE_ACTIVITY;
constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MAX = SatParameters_ClauseOrdering_CLAUSE_LBD;
constexpr int SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE = SatParameters_ClauseOrdering_ClauseOrdering_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ClauseOrdering_descriptor();
template<typename T>
inline const std::string& SatParameters_ClauseOrdering_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_ClauseOrdering>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_ClauseOrdering_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_ClauseOrdering_descriptor(), enum_t_value);
}
inline bool SatParameters_ClauseOrdering_Parse(
    const std::string& name, SatParameters_ClauseOrdering* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ClauseOrdering>(
    SatParameters_ClauseOrdering_descriptor(), name, value);
}
enum SatParameters_RestartAlgorithm : int {
  SatParameters_RestartAlgorithm_NO_RESTART = 0,
  SatParameters_RestartAlgorithm_LUBY_RESTART = 1,
  SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART = 2,
  SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART = 3,
  SatParameters_RestartAlgorithm_FIXED_RESTART = 4
};
bool SatParameters_RestartAlgorithm_IsValid(int value);
constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MIN = SatParameters_RestartAlgorithm_NO_RESTART;
constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MAX = SatParameters_RestartAlgorithm_FIXED_RESTART;
constexpr int SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE = SatParameters_RestartAlgorithm_RestartAlgorithm_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_RestartAlgorithm_descriptor();
template<typename T>
inline const std::string& SatParameters_RestartAlgorithm_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_RestartAlgorithm>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_RestartAlgorithm_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_RestartAlgorithm_descriptor(), enum_t_value);
}
inline bool SatParameters_RestartAlgorithm_Parse(
    const std::string& name, SatParameters_RestartAlgorithm* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_RestartAlgorithm>(
    SatParameters_RestartAlgorithm_descriptor(), name, value);
}
enum SatParameters_MaxSatAssumptionOrder : int {
  SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER = 0,
  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH = 1,
  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT = 2
};
bool SatParameters_MaxSatAssumptionOrder_IsValid(int value);
constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN = SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER;
constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX = SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT;
constexpr int SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE = SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_MaxSatAssumptionOrder_descriptor();
template<typename T>
inline const std::string& SatParameters_MaxSatAssumptionOrder_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_MaxSatAssumptionOrder>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_MaxSatAssumptionOrder_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_MaxSatAssumptionOrder_descriptor(), enum_t_value);
}
inline bool SatParameters_MaxSatAssumptionOrder_Parse(
    const std::string& name, SatParameters_MaxSatAssumptionOrder* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_MaxSatAssumptionOrder>(
    SatParameters_MaxSatAssumptionOrder_descriptor(), name, value);
}
enum SatParameters_MaxSatStratificationAlgorithm : int {
  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE = 0,
  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT = 1,
  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT = 2
};
bool SatParameters_MaxSatStratificationAlgorithm_IsValid(int value);
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN = SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE;
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX = SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT;
constexpr int SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE = SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_MaxSatStratificationAlgorithm_descriptor();
template<typename T>
inline const std::string& SatParameters_MaxSatStratificationAlgorithm_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SatParameters_MaxSatStratificationAlgorithm>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SatParameters_MaxSatStratificationAlgorithm_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SatParameters_MaxSatStratificationAlgorithm_descriptor(), enum_t_value);
}
inline bool SatParameters_MaxSatStratificationAlgorithm_Parse(
    const std::string& name, SatParameters_MaxSatStratificationAlgorithm* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_MaxSatStratificationAlgorithm>(
    SatParameters_MaxSatStratificationAlgorithm_descriptor(), name, value);
}
enum SatParameters_SearchBranching : int {
  SatParameters_SearchBranching_AUTOMATIC_SEARCH = 0,
  SatParameters_SearchBranching_FIXED_SEARCH = 1,
  SatParameters_SearchBranching_PORTFOLIO_SEARCH = 2,
  SatParameters_SearchBranching_LP_SEARCH = 3,
  SatParameters_SearchBranching_PSEUDO_COST_SEARCH = 4,
  SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH = 5,
  SatParameters_SearchBranching_HINT_SEARCH = 6
};
bool SatParameters_SearchBranching_IsValid(int value);
constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MIN = SatParameters_SearchBranching_AUTOMATIC_SEARCH;
constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MAX = SatParameters_SearchBranching_HINT_SEARCH;
constexpr int SatParameters_SearchBranching_SearchBranching_ARRAYSIZE = SatParameters_SearchBranching_SearchBranching_MAX + 1;

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

class SatParameters :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.SatParameters) */ {
 public:
  SatParameters();
  virtual ~SatParameters();

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

  inline SatParameters& operator=(const SatParameters& from) {
    CopyFrom(from);
    return *this;
  }
  inline SatParameters& operator=(SatParameters&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SatParameters& default_instance();

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

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

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

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

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

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

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SatParameters* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "operations_research.sat.SatParameters";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
    return ::descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef SatParameters_VariableOrder VariableOrder;
  static constexpr VariableOrder IN_ORDER =
    SatParameters_VariableOrder_IN_ORDER;
  static constexpr VariableOrder IN_REVERSE_ORDER =
    SatParameters_VariableOrder_IN_REVERSE_ORDER;
  static constexpr VariableOrder IN_RANDOM_ORDER =
    SatParameters_VariableOrder_IN_RANDOM_ORDER;
  static inline bool VariableOrder_IsValid(int value) {
    return SatParameters_VariableOrder_IsValid(value);
  }
  static constexpr VariableOrder VariableOrder_MIN =
    SatParameters_VariableOrder_VariableOrder_MIN;
  static constexpr VariableOrder VariableOrder_MAX =
    SatParameters_VariableOrder_VariableOrder_MAX;
  static constexpr int VariableOrder_ARRAYSIZE =
    SatParameters_VariableOrder_VariableOrder_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  VariableOrder_descriptor() {
    return SatParameters_VariableOrder_descriptor();
  }
  template<typename T>
  static inline const std::string& VariableOrder_Name(T enum_t_value) {
    static_assert(::std::is_same<T, VariableOrder>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function VariableOrder_Name.");
    return SatParameters_VariableOrder_Name(enum_t_value);
  }
  static inline bool VariableOrder_Parse(const std::string& name,
      VariableOrder* value) {
    return SatParameters_VariableOrder_Parse(name, value);
  }

  typedef SatParameters_Polarity Polarity;
  static constexpr Polarity POLARITY_TRUE =
    SatParameters_Polarity_POLARITY_TRUE;
  static constexpr Polarity POLARITY_FALSE =
    SatParameters_Polarity_POLARITY_FALSE;
  static constexpr Polarity POLARITY_RANDOM =
    SatParameters_Polarity_POLARITY_RANDOM;
  static constexpr Polarity POLARITY_WEIGHTED_SIGN =
    SatParameters_Polarity_POLARITY_WEIGHTED_SIGN;
  static constexpr Polarity POLARITY_REVERSE_WEIGHTED_SIGN =
    SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN;
  static inline bool Polarity_IsValid(int value) {
    return SatParameters_Polarity_IsValid(value);
  }
  static constexpr Polarity Polarity_MIN =
    SatParameters_Polarity_Polarity_MIN;
  static constexpr Polarity Polarity_MAX =
    SatParameters_Polarity_Polarity_MAX;
  static constexpr int Polarity_ARRAYSIZE =
    SatParameters_Polarity_Polarity_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Polarity_descriptor() {
    return SatParameters_Polarity_descriptor();
  }
  template<typename T>
  static inline const std::string& Polarity_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Polarity>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Polarity_Name.");
    return SatParameters_Polarity_Name(enum_t_value);
  }
  static inline bool Polarity_Parse(const std::string& name,
      Polarity* value) {
    return SatParameters_Polarity_Parse(name, value);
  }

  typedef SatParameters_ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm;
  static constexpr ConflictMinimizationAlgorithm NONE =
    SatParameters_ConflictMinimizationAlgorithm_NONE;
  static constexpr ConflictMinimizationAlgorithm SIMPLE =
    SatParameters_ConflictMinimizationAlgorithm_SIMPLE;
  static constexpr ConflictMinimizationAlgorithm RECURSIVE =
    SatParameters_ConflictMinimizationAlgorithm_RECURSIVE;
  static constexpr ConflictMinimizationAlgorithm EXPERIMENTAL =
    SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL;
  static inline bool ConflictMinimizationAlgorithm_IsValid(int value) {
    return SatParameters_ConflictMinimizationAlgorithm_IsValid(value);
  }
  static constexpr ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm_MIN =
    SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN;
  static constexpr ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm_MAX =
    SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX;
  static constexpr int ConflictMinimizationAlgorithm_ARRAYSIZE =
    SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ConflictMinimizationAlgorithm_descriptor() {
    return SatParameters_ConflictMinimizationAlgorithm_descriptor();
  }
  template<typename T>
  static inline const std::string& ConflictMinimizationAlgorithm_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ConflictMinimizationAlgorithm>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ConflictMinimizationAlgorithm_Name.");
    return SatParameters_ConflictMinimizationAlgorithm_Name(enum_t_value);
  }
  static inline bool ConflictMinimizationAlgorithm_Parse(const std::string& name,
      ConflictMinimizationAlgorithm* value) {
    return SatParameters_ConflictMinimizationAlgorithm_Parse(name, value);
  }

  typedef SatParameters_BinaryMinizationAlgorithm BinaryMinizationAlgorithm;
  static constexpr BinaryMinizationAlgorithm NO_BINARY_MINIMIZATION =
    SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION;
  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_FIRST =
    SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST;
  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION =
    SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION;
  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_WITH_REACHABILITY =
    SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY;
  static constexpr BinaryMinizationAlgorithm EXPERIMENTAL_BINARY_MINIMIZATION =
    SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION;
  static inline bool BinaryMinizationAlgorithm_IsValid(int value) {
    return SatParameters_BinaryMinizationAlgorithm_IsValid(value);
  }
  static constexpr BinaryMinizationAlgorithm BinaryMinizationAlgorithm_MIN =
    SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN;
  static constexpr BinaryMinizationAlgorithm BinaryMinizationAlgorithm_MAX =
    SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX;
  static constexpr int BinaryMinizationAlgorithm_ARRAYSIZE =
    SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  BinaryMinizationAlgorithm_descriptor() {
    return SatParameters_BinaryMinizationAlgorithm_descriptor();
  }
  template<typename T>
  static inline const std::string& BinaryMinizationAlgorithm_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BinaryMinizationAlgorithm>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BinaryMinizationAlgorithm_Name.");
    return SatParameters_BinaryMinizationAlgorithm_Name(enum_t_value);
  }
  static inline bool BinaryMinizationAlgorithm_Parse(const std::string& name,
      BinaryMinizationAlgorithm* value) {
    return SatParameters_BinaryMinizationAlgorithm_Parse(name, value);
  }

  typedef SatParameters_ClauseProtection ClauseProtection;
  static constexpr ClauseProtection PROTECTION_NONE =
    SatParameters_ClauseProtection_PROTECTION_NONE;
  static constexpr ClauseProtection PROTECTION_ALWAYS =
    SatParameters_ClauseProtection_PROTECTION_ALWAYS;
  static constexpr ClauseProtection PROTECTION_LBD =
    SatParameters_ClauseProtection_PROTECTION_LBD;
  static inline bool ClauseProtection_IsValid(int value) {
    return SatParameters_ClauseProtection_IsValid(value);
  }
  static constexpr ClauseProtection ClauseProtection_MIN =
    SatParameters_ClauseProtection_ClauseProtection_MIN;
  static constexpr ClauseProtection ClauseProtection_MAX =
    SatParameters_ClauseProtection_ClauseProtection_MAX;
  static constexpr int ClauseProtection_ARRAYSIZE =
    SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ClauseProtection_descriptor() {
    return SatParameters_ClauseProtection_descriptor();
  }
  template<typename T>
  static inline const std::string& ClauseProtection_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ClauseProtection>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ClauseProtection_Name.");
    return SatParameters_ClauseProtection_Name(enum_t_value);
  }
  static inline bool ClauseProtection_Parse(const std::string& name,
      ClauseProtection* value) {
    return SatParameters_ClauseProtection_Parse(name, value);
  }

  typedef SatParameters_ClauseOrdering ClauseOrdering;
  static constexpr ClauseOrdering CLAUSE_ACTIVITY =
    SatParameters_ClauseOrdering_CLAUSE_ACTIVITY;
  static constexpr ClauseOrdering CLAUSE_LBD =
    SatParameters_ClauseOrdering_CLAUSE_LBD;
  static inline bool ClauseOrdering_IsValid(int value) {
    return SatParameters_ClauseOrdering_IsValid(value);
  }
  static constexpr ClauseOrdering ClauseOrdering_MIN =
    SatParameters_ClauseOrdering_ClauseOrdering_MIN;
  static constexpr ClauseOrdering ClauseOrdering_MAX =
    SatParameters_ClauseOrdering_ClauseOrdering_MAX;
  static constexpr int ClauseOrdering_ARRAYSIZE =
    SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  ClauseOrdering_descriptor() {
    return SatParameters_ClauseOrdering_descriptor();
  }
  template<typename T>
  static inline const std::string& ClauseOrdering_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ClauseOrdering>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ClauseOrdering_Name.");
    return SatParameters_ClauseOrdering_Name(enum_t_value);
  }
  static inline bool ClauseOrdering_Parse(const std::string& name,
      ClauseOrdering* value) {
    return SatParameters_ClauseOrdering_Parse(name, value);
  }

  typedef SatParameters_RestartAlgorithm RestartAlgorithm;
  static constexpr RestartAlgorithm NO_RESTART =
    SatParameters_RestartAlgorithm_NO_RESTART;
  static constexpr RestartAlgorithm LUBY_RESTART =
    SatParameters_RestartAlgorithm_LUBY_RESTART;
  static constexpr RestartAlgorithm DL_MOVING_AVERAGE_RESTART =
    SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART;
  static constexpr RestartAlgorithm LBD_MOVING_AVERAGE_RESTART =
    SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART;
  static constexpr RestartAlgorithm FIXED_RESTART =
    SatParameters_RestartAlgorithm_FIXED_RESTART;
  static inline bool RestartAlgorithm_IsValid(int value) {
    return SatParameters_RestartAlgorithm_IsValid(value);
  }
  static constexpr RestartAlgorithm RestartAlgorithm_MIN =
    SatParameters_RestartAlgorithm_RestartAlgorithm_MIN;
  static constexpr RestartAlgorithm RestartAlgorithm_MAX =
    SatParameters_RestartAlgorithm_RestartAlgorithm_MAX;
  static constexpr int RestartAlgorithm_ARRAYSIZE =
    SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  RestartAlgorithm_descriptor() {
    return SatParameters_RestartAlgorithm_descriptor();
  }
  template<typename T>
  static inline const std::string& RestartAlgorithm_Name(T enum_t_value) {
    static_assert(::std::is_same<T, RestartAlgorithm>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function RestartAlgorithm_Name.");
    return SatParameters_RestartAlgorithm_Name(enum_t_value);
  }
  static inline bool RestartAlgorithm_Parse(const std::string& name,
      RestartAlgorithm* value) {
    return SatParameters_RestartAlgorithm_Parse(name, value);
  }

  typedef SatParameters_MaxSatAssumptionOrder MaxSatAssumptionOrder;
  static constexpr MaxSatAssumptionOrder DEFAULT_ASSUMPTION_ORDER =
    SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER;
  static constexpr MaxSatAssumptionOrder ORDER_ASSUMPTION_BY_DEPTH =
    SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH;
  static constexpr MaxSatAssumptionOrder ORDER_ASSUMPTION_BY_WEIGHT =
    SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT;
  static inline bool MaxSatAssumptionOrder_IsValid(int value) {
    return SatParameters_MaxSatAssumptionOrder_IsValid(value);
  }
  static constexpr MaxSatAssumptionOrder MaxSatAssumptionOrder_MIN =
    SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN;
  static constexpr MaxSatAssumptionOrder MaxSatAssumptionOrder_MAX =
    SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX;
  static constexpr int MaxSatAssumptionOrder_ARRAYSIZE =
    SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MaxSatAssumptionOrder_descriptor() {
    return SatParameters_MaxSatAssumptionOrder_descriptor();
  }
  template<typename T>
  static inline const std::string& MaxSatAssumptionOrder_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MaxSatAssumptionOrder>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MaxSatAssumptionOrder_Name.");
    return SatParameters_MaxSatAssumptionOrder_Name(enum_t_value);
  }
  static inline bool MaxSatAssumptionOrder_Parse(const std::string& name,
      MaxSatAssumptionOrder* value) {
    return SatParameters_MaxSatAssumptionOrder_Parse(name, value);
  }

  typedef SatParameters_MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm;
  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_NONE =
    SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE;
  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_DESCENT =
    SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT;
  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_ASCENT =
    SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT;
  static inline bool MaxSatStratificationAlgorithm_IsValid(int value) {
    return SatParameters_MaxSatStratificationAlgorithm_IsValid(value);
  }
  static constexpr MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm_MIN =
    SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN;
  static constexpr MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm_MAX =
    SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX;
  static constexpr int MaxSatStratificationAlgorithm_ARRAYSIZE =
    SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  MaxSatStratificationAlgorithm_descriptor() {
    return SatParameters_MaxSatStratificationAlgorithm_descriptor();
  }
  template<typename T>
  static inline const std::string& MaxSatStratificationAlgorithm_Name(T enum_t_value) {
    static_assert(::std::is_same<T, MaxSatStratificationAlgorithm>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function MaxSatStratificationAlgorithm_Name.");
    return SatParameters_MaxSatStratificationAlgorithm_Name(enum_t_value);
  }
  static inline bool MaxSatStratificationAlgorithm_Parse(const std::string& name,
      MaxSatStratificationAlgorithm* value) {
    return SatParameters_MaxSatStratificationAlgorithm_Parse(name, value);
  }

  typedef SatParameters_SearchBranching SearchBranching;
  static constexpr SearchBranching AUTOMATIC_SEARCH =
    SatParameters_SearchBranching_AUTOMATIC_SEARCH;
  static constexpr SearchBranching FIXED_SEARCH =
    SatParameters_SearchBranching_FIXED_SEARCH;
  static constexpr SearchBranching PORTFOLIO_SEARCH =
    SatParameters_SearchBranching_PORTFOLIO_SEARCH;
  static constexpr SearchBranching LP_SEARCH =
    SatParameters_SearchBranching_LP_SEARCH;
  static constexpr SearchBranching PSEUDO_COST_SEARCH =
    SatParameters_SearchBranching_PSEUDO_COST_SEARCH;
  static constexpr SearchBranching PORTFOLIO_WITH_QUICK_RESTART_SEARCH =
    SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH;
  static constexpr SearchBranching HINT_SEARCH =
    SatParameters_SearchBranching_HINT_SEARCH;
  static inline bool SearchBranching_IsValid(int value) {
    return SatParameters_SearchBranching_IsValid(value);
  }
  static constexpr SearchBranching SearchBranching_MIN =
    SatParameters_SearchBranching_SearchBranching_MIN;
  static constexpr SearchBranching SearchBranching_MAX =
    SatParameters_SearchBranching_SearchBranching_MAX;
  static constexpr int SearchBranching_ARRAYSIZE =
    SatParameters_SearchBranching_SearchBranching_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  SearchBranching_descriptor() {
    return SatParameters_SearchBranching_descriptor();
  }
  template<typename T>
  static inline const std::string& SearchBranching_Name(T enum_t_value) {
    static_assert(::std::is_same<T, SearchBranching>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function SearchBranching_Name.");
    return SatParameters_SearchBranching_Name(enum_t_value);
  }
  static inline bool SearchBranching_Parse(const std::string& name,
      SearchBranching* value) {
    return SatParameters_SearchBranching_Parse(name, value);
  }

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

  // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  int restart_algorithms_size() const;
  void clear_restart_algorithms();
  static const int kRestartAlgorithmsFieldNumber = 61;
  ::operations_research::sat::SatParameters_RestartAlgorithm restart_algorithms(int index) const;
  void set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value);
  void add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& restart_algorithms() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_restart_algorithms();

  // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  bool has_default_restart_algorithms() const;
  void clear_default_restart_algorithms();
  static const int kDefaultRestartAlgorithmsFieldNumber = 70;
  const std::string& default_restart_algorithms() const;
  void set_default_restart_algorithms(const std::string& value);
  void set_default_restart_algorithms(std::string&& value);
  void set_default_restart_algorithms(const char* value);
  void set_default_restart_algorithms(const char* value, size_t size);
  std::string* mutable_default_restart_algorithms();
  std::string* release_default_restart_algorithms();
  void set_allocated_default_restart_algorithms(std::string* default_restart_algorithms);

  // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  bool has_preferred_variable_order() const;
  void clear_preferred_variable_order();
  static const int kPreferredVariableOrderFieldNumber = 1;
  ::operations_research::sat::SatParameters_VariableOrder preferred_variable_order() const;
  void set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value);

  // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  bool has_max_sat_assumption_order() const;
  void clear_max_sat_assumption_order();
  static const int kMaxSatAssumptionOrderFieldNumber = 51;
  ::operations_research::sat::SatParameters_MaxSatAssumptionOrder max_sat_assumption_order() const;
  void set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value);

  // optional double random_branches_ratio = 32 [default = 0];
  bool has_random_branches_ratio() const;
  void clear_random_branches_ratio();
  static const int kRandomBranchesRatioFieldNumber = 32;
  double random_branches_ratio() const;
  void set_random_branches_ratio(double value);

  // optional double random_polarity_ratio = 45 [default = 0];
  bool has_random_polarity_ratio() const;
  void clear_random_polarity_ratio();
  static const int kRandomPolarityRatioFieldNumber = 45;
  double random_polarity_ratio() const;
  void set_random_polarity_ratio(double value);

  // optional bool use_pb_resolution = 43 [default = false];
  bool has_use_pb_resolution() const;
  void clear_use_pb_resolution();
  static const int kUsePbResolutionFieldNumber = 43;
  bool use_pb_resolution() const;
  void set_use_pb_resolution(bool value);

  // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  bool has_minimize_reduction_during_pb_resolution() const;
  void clear_minimize_reduction_during_pb_resolution();
  static const int kMinimizeReductionDuringPbResolutionFieldNumber = 48;
  bool minimize_reduction_during_pb_resolution() const;
  void set_minimize_reduction_during_pb_resolution(bool value);

  // optional bool max_sat_reverse_assumption_order = 52 [default = false];
  bool has_max_sat_reverse_assumption_order() const;
  void clear_max_sat_reverse_assumption_order();
  static const int kMaxSatReverseAssumptionOrderFieldNumber = 52;
  bool max_sat_reverse_assumption_order() const;
  void set_max_sat_reverse_assumption_order(bool value);

  // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  bool has_use_overload_checker_in_cumulative_constraint() const;
  void clear_use_overload_checker_in_cumulative_constraint();
  static const int kUseOverloadCheckerInCumulativeConstraintFieldNumber = 78;
  bool use_overload_checker_in_cumulative_constraint() const;
  void set_use_overload_checker_in_cumulative_constraint(bool value);

  // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  bool has_clause_cleanup_protection() const;
  void clear_clause_cleanup_protection();
  static const int kClauseCleanupProtectionFieldNumber = 58;
  ::operations_research::sat::SatParameters_ClauseProtection clause_cleanup_protection() const;
  void set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value);

  // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  bool has_clause_cleanup_ordering() const;
  void clear_clause_cleanup_ordering();
  static const int kClauseCleanupOrderingFieldNumber = 60;
  ::operations_research::sat::SatParameters_ClauseOrdering clause_cleanup_ordering() const;
  void set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value);

  // optional bool use_erwa_heuristic = 75 [default = false];
  bool has_use_erwa_heuristic() const;
  void clear_use_erwa_heuristic();
  static const int kUseErwaHeuristicFieldNumber = 75;
  bool use_erwa_heuristic() const;
  void set_use_erwa_heuristic(bool value);

  // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  bool has_also_bump_variables_in_conflict_reasons() const;
  void clear_also_bump_variables_in_conflict_reasons();
  static const int kAlsoBumpVariablesInConflictReasonsFieldNumber = 77;
  bool also_bump_variables_in_conflict_reasons() const;
  void set_also_bump_variables_in_conflict_reasons(bool value);

  // optional bool use_blocking_restart = 64 [default = false];
  bool has_use_blocking_restart() const;
  void clear_use_blocking_restart();
  static const int kUseBlockingRestartFieldNumber = 64;
  bool use_blocking_restart() const;
  void set_use_blocking_restart(bool value);

  // optional bool log_search_progress = 41 [default = false];
  bool has_log_search_progress() const;
  void clear_log_search_progress();
  static const int kLogSearchProgressFieldNumber = 41;
  bool log_search_progress() const;
  void set_log_search_progress(bool value);

  // optional double strategy_change_increase_ratio = 69 [default = 0];
  bool has_strategy_change_increase_ratio() const;
  void clear_strategy_change_increase_ratio();
  static const int kStrategyChangeIncreaseRatioFieldNumber = 69;
  double strategy_change_increase_ratio() const;
  void set_strategy_change_increase_ratio(double value);

  // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  bool has_num_conflicts_before_strategy_changes() const;
  void clear_num_conflicts_before_strategy_changes();
  static const int kNumConflictsBeforeStrategyChangesFieldNumber = 68;
  ::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes() const;
  void set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  bool has_search_branching() const;
  void clear_search_branching();
  static const int kSearchBranchingFieldNumber = 82;
  ::operations_research::sat::SatParameters_SearchBranching search_branching() const;
  void set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);

  // optional double initial_variables_activity = 76 [default = 0];
  bool has_initial_variables_activity() const;
  void clear_initial_variables_activity();
  static const int kInitialVariablesActivityFieldNumber = 76;
  double initial_variables_activity() const;
  void set_initial_variables_activity(double value);

  // optional bool exploit_best_solution = 130 [default = false];
  bool has_exploit_best_solution() const;
  void clear_exploit_best_solution();
  static const int kExploitBestSolutionFieldNumber = 130;
  bool exploit_best_solution() const;
  void set_exploit_best_solution(bool value);

  // optional bool optimize_with_core = 83 [default = false];
  bool has_optimize_with_core() const;
  void clear_optimize_with_core();
  static const int kOptimizeWithCoreFieldNumber = 83;
  bool optimize_with_core() const;
  void set_optimize_with_core(bool value);

  // optional bool optimize_with_max_hs = 85 [default = false];
  bool has_optimize_with_max_hs() const;
  void clear_optimize_with_max_hs();
  static const int kOptimizeWithMaxHsFieldNumber = 85;
  bool optimize_with_max_hs() const;
  void set_optimize_with_max_hs(bool value);

  // optional bool enumerate_all_solutions = 87 [default = false];
  bool has_enumerate_all_solutions() const;
  void clear_enumerate_all_solutions();
  static const int kEnumerateAllSolutionsFieldNumber = 87;
  bool enumerate_all_solutions() const;
  void set_enumerate_all_solutions(bool value);

  // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  bool has_use_timetable_edge_finding_in_cumulative_constraint() const;
  void clear_use_timetable_edge_finding_in_cumulative_constraint();
  static const int kUseTimetableEdgeFindingInCumulativeConstraintFieldNumber = 79;
  bool use_timetable_edge_finding_in_cumulative_constraint() const;
  void set_use_timetable_edge_finding_in_cumulative_constraint(bool value);

  // optional bool only_add_cuts_at_level_zero = 92 [default = false];
  bool has_only_add_cuts_at_level_zero() const;
  void clear_only_add_cuts_at_level_zero();
  static const int kOnlyAddCutsAtLevelZeroFieldNumber = 92;
  bool only_add_cuts_at_level_zero() const;
  void set_only_add_cuts_at_level_zero(bool value);

  // optional bool add_knapsack_cuts = 111 [default = false];
  bool has_add_knapsack_cuts() const;
  void clear_add_knapsack_cuts();
  static const int kAddKnapsackCutsFieldNumber = 111;
  bool add_knapsack_cuts() const;
  void set_add_knapsack_cuts(bool value);

  // optional bool add_cg_cuts = 117 [default = false];
  bool has_add_cg_cuts() const;
  void clear_add_cg_cuts();
  static const int kAddCgCutsFieldNumber = 117;
  bool add_cg_cuts() const;
  void set_add_cg_cuts(bool value);

  // optional int64 search_randomization_tolerance = 104 [default = 0];
  bool has_search_randomization_tolerance() const;
  void clear_search_randomization_tolerance();
  static const int kSearchRandomizationToleranceFieldNumber = 104;
  ::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance() const;
  void set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional double min_orthogonality_for_lp_constraints = 115 [default = 0];
  bool has_min_orthogonality_for_lp_constraints() const;
  void clear_min_orthogonality_for_lp_constraints();
  static const int kMinOrthogonalityForLpConstraintsFieldNumber = 115;
  double min_orthogonality_for_lp_constraints() const;
  void set_min_orthogonality_for_lp_constraints(double value);

  // optional bool use_lns_only = 101 [default = false];
  bool has_use_lns_only() const;
  void clear_use_lns_only();
  static const int kUseLnsOnlyFieldNumber = 101;
  bool use_lns_only() const;
  void set_use_lns_only(bool value);

  // optional bool lns_focus_on_decision_variables = 105 [default = false];
  bool has_lns_focus_on_decision_variables() const;
  void clear_lns_focus_on_decision_variables();
  static const int kLnsFocusOnDecisionVariablesFieldNumber = 105;
  bool lns_focus_on_decision_variables() const;
  void set_lns_focus_on_decision_variables(bool value);

  // optional bool randomize_search = 103 [default = false];
  bool has_randomize_search() const;
  void clear_randomize_search();
  static const int kRandomizeSearchFieldNumber = 103;
  bool randomize_search() const;
  void set_randomize_search(bool value);

  // optional bool use_combined_no_overlap = 133 [default = false];
  bool has_use_combined_no_overlap() const;
  void clear_use_combined_no_overlap();
  static const int kUseCombinedNoOverlapFieldNumber = 133;
  bool use_combined_no_overlap() const;
  void set_use_combined_no_overlap(bool value);

  // optional bool fill_tightened_domains_in_response = 132 [default = false];
  bool has_fill_tightened_domains_in_response() const;
  void clear_fill_tightened_domains_in_response();
  static const int kFillTightenedDomainsInResponseFieldNumber = 132;
  bool fill_tightened_domains_in_response() const;
  void set_fill_tightened_domains_in_response(bool value);

  // optional bool stop_after_first_solution = 98 [default = false];
  bool has_stop_after_first_solution() const;
  void clear_stop_after_first_solution();
  static const int kStopAfterFirstSolutionFieldNumber = 98;
  bool stop_after_first_solution() const;
  void set_stop_after_first_solution(bool value);

  // optional bool interleave_search = 136 [default = false];
  bool has_interleave_search() const;
  void clear_interleave_search();
  static const int kInterleaveSearchFieldNumber = 136;
  bool interleave_search() const;
  void set_interleave_search(bool value);

  // optional bool deterministic_parallel_search = 134 [default = false];
  bool has_deterministic_parallel_search() const;
  void clear_deterministic_parallel_search();
  static const int kDeterministicParallelSearchFieldNumber = 134;
  bool deterministic_parallel_search() const;
  void set_deterministic_parallel_search(bool value);

  // optional int32 mip_max_activity_exponent = 127 [default = 53];
  bool has_mip_max_activity_exponent() const;
  void clear_mip_max_activity_exponent();
  static const int kMipMaxActivityExponentFieldNumber = 127;
  ::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent() const;
  void set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  bool has_initial_polarity() const;
  void clear_initial_polarity();
  static const int kInitialPolarityFieldNumber = 2;
  ::operations_research::sat::SatParameters_Polarity initial_polarity() const;
  void set_initial_polarity(::operations_research::sat::SatParameters_Polarity value);

  // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  bool has_minimization_algorithm() const;
  void clear_minimization_algorithm();
  static const int kMinimizationAlgorithmFieldNumber = 4;
  ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm minimization_algorithm() const;
  void set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value);

  // optional int32 clause_cleanup_period = 11 [default = 10000];
  bool has_clause_cleanup_period() const;
  void clear_clause_cleanup_period();
  static const int kClauseCleanupPeriodFieldNumber = 11;
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period() const;
  void set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 clause_cleanup_target = 13 [default = 10000];
  bool has_clause_cleanup_target() const;
  void clear_clause_cleanup_target();
  static const int kClauseCleanupTargetFieldNumber = 13;
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target() const;
  void set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional double variable_activity_decay = 15 [default = 0.8];
  bool has_variable_activity_decay() const;
  void clear_variable_activity_decay();
  static const int kVariableActivityDecayFieldNumber = 15;
  double variable_activity_decay() const;
  void set_variable_activity_decay(double value);

  // optional double max_variable_activity_value = 16 [default = 1e+100];
  bool has_max_variable_activity_value() const;
  void clear_max_variable_activity_value();
  static const int kMaxVariableActivityValueFieldNumber = 16;
  double max_variable_activity_value() const;
  void set_max_variable_activity_value(double value);

  // optional double clause_activity_decay = 17 [default = 0.999];
  bool has_clause_activity_decay() const;
  void clear_clause_activity_decay();
  static const int kClauseActivityDecayFieldNumber = 17;
  double clause_activity_decay() const;
  void set_clause_activity_decay(double value);

  // optional double max_clause_activity_value = 18 [default = 1e+20];
  bool has_max_clause_activity_value() const;
  void clear_max_clause_activity_value();
  static const int kMaxClauseActivityValueFieldNumber = 18;
  double max_clause_activity_value() const;
  void set_max_clause_activity_value(double value);

  // optional double glucose_max_decay = 22 [default = 0.95];
  bool has_glucose_max_decay() const;
  void clear_glucose_max_decay();
  static const int kGlucoseMaxDecayFieldNumber = 22;
  double glucose_max_decay() const;
  void set_glucose_max_decay(double value);

  // optional double glucose_decay_increment = 23 [default = 0.01];
  bool has_glucose_decay_increment() const;
  void clear_glucose_decay_increment();
  static const int kGlucoseDecayIncrementFieldNumber = 23;
  double glucose_decay_increment() const;
  void set_glucose_decay_increment(double value);

  // optional int32 glucose_decay_increment_period = 24 [default = 5000];
  bool has_glucose_decay_increment_period() const;
  void clear_glucose_decay_increment_period();
  static const int kGlucoseDecayIncrementPeriodFieldNumber = 24;
  ::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period() const;
  void set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 restart_period = 30 [default = 50];
  bool has_restart_period() const;
  void clear_restart_period();
  static const int kRestartPeriodFieldNumber = 30;
  ::PROTOBUF_NAMESPACE_ID::int32 restart_period() const;
  void set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 random_seed = 31 [default = 1];
  bool has_random_seed() const;
  void clear_random_seed();
  static const int kRandomSeedFieldNumber = 31;
  ::PROTOBUF_NAMESPACE_ID::int32 random_seed() const;
  void set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  bool has_binary_minimization_algorithm() const;
  void clear_binary_minimization_algorithm();
  static const int kBinaryMinimizationAlgorithmFieldNumber = 34;
  ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm binary_minimization_algorithm() const;
  void set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value);

  // optional double max_time_in_seconds = 36 [default = inf];
  bool has_max_time_in_seconds() const;
  void clear_max_time_in_seconds();
  static const int kMaxTimeInSecondsFieldNumber = 36;
  double max_time_in_seconds() const;
  void set_max_time_in_seconds(double value);

  // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  bool has_max_number_of_conflicts() const;
  void clear_max_number_of_conflicts();
  static const int kMaxNumberOfConflictsFieldNumber = 37;
  ::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts() const;
  void set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 max_memory_in_mb = 40 [default = 10000];
  bool has_max_memory_in_mb() const;
  void clear_max_memory_in_mb();
  static const int kMaxMemoryInMbFieldNumber = 40;
  ::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb() const;
  void set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional bool use_phase_saving = 44 [default = true];
  bool has_use_phase_saving() const;
  void clear_use_phase_saving();
  static const int kUsePhaseSavingFieldNumber = 44;
  bool use_phase_saving() const;
  void set_use_phase_saving(bool value);

  // optional bool subsumption_during_conflict_analysis = 56 [default = true];
  bool has_subsumption_during_conflict_analysis() const;
  void clear_subsumption_during_conflict_analysis();
  static const int kSubsumptionDuringConflictAnalysisFieldNumber = 56;
  bool subsumption_during_conflict_analysis() const;
  void set_subsumption_during_conflict_analysis(bool value);

  // optional bool treat_binary_clauses_separately = 33 [default = true];
  bool has_treat_binary_clauses_separately() const;
  void clear_treat_binary_clauses_separately();
  static const int kTreatBinaryClausesSeparatelyFieldNumber = 33;
  bool treat_binary_clauses_separately() const;
  void set_treat_binary_clauses_separately(bool value);

  // optional bool count_assumption_levels_in_lbd = 49 [default = true];
  bool has_count_assumption_levels_in_lbd() const;
  void clear_count_assumption_levels_in_lbd();
  static const int kCountAssumptionLevelsInLbdFieldNumber = 49;
  bool count_assumption_levels_in_lbd() const;
  void set_count_assumption_levels_in_lbd(bool value);

  // optional int32 pb_cleanup_increment = 46 [default = 200];
  bool has_pb_cleanup_increment() const;
  void clear_pb_cleanup_increment();
  static const int kPbCleanupIncrementFieldNumber = 46;
  ::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment() const;
  void set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional double pb_cleanup_ratio = 47 [default = 0.5];
  bool has_pb_cleanup_ratio() const;
  void clear_pb_cleanup_ratio();
  static const int kPbCleanupRatioFieldNumber = 47;
  double pb_cleanup_ratio() const;
  void set_pb_cleanup_ratio(double value);

  // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  bool has_max_sat_stratification() const;
  void clear_max_sat_stratification();
  static const int kMaxSatStratificationFieldNumber = 53;
  ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm max_sat_stratification() const;
  void set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value);

  // optional int32 presolve_bve_threshold = 54 [default = 500];
  bool has_presolve_bve_threshold() const;
  void clear_presolve_bve_threshold();
  static const int kPresolveBveThresholdFieldNumber = 54;
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold() const;
  void set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  bool has_presolve_probing_deterministic_time_limit() const;
  void clear_presolve_probing_deterministic_time_limit();
  static const int kPresolveProbingDeterministicTimeLimitFieldNumber = 57;
  double presolve_probing_deterministic_time_limit() const;
  void set_presolve_probing_deterministic_time_limit(double value);

  // optional int32 presolve_bve_clause_weight = 55 [default = 3];
  bool has_presolve_bve_clause_weight() const;
  void clear_presolve_bve_clause_weight();
  static const int kPresolveBveClauseWeightFieldNumber = 55;
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight() const;
  void set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  bool has_clause_cleanup_lbd_bound() const;
  void clear_clause_cleanup_lbd_bound();
  static const int kClauseCleanupLbdBoundFieldNumber = 59;
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound() const;
  void set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool presolve_blocked_clause = 88 [default = true];
  bool has_presolve_blocked_clause() const;
  void clear_presolve_blocked_clause();
  static const int kPresolveBlockedClauseFieldNumber = 88;
  bool presolve_blocked_clause() const;
  void set_presolve_blocked_clause(bool value);

  // optional bool presolve_use_bva = 72 [default = true];
  bool has_presolve_use_bva() const;
  void clear_presolve_use_bva();
  static const int kPresolveUseBvaFieldNumber = 72;
  bool presolve_use_bva() const;
  void set_presolve_use_bva(bool value);

  // optional bool use_optimization_hints = 35 [default = true];
  bool has_use_optimization_hints() const;
  void clear_use_optimization_hints();
  static const int kUseOptimizationHintsFieldNumber = 35;
  bool use_optimization_hints() const;
  void set_use_optimization_hints(bool value);

  // optional bool minimize_core = 50 [default = true];
  bool has_minimize_core() const;
  void clear_minimize_core();
  static const int kMinimizeCoreFieldNumber = 50;
  bool minimize_core() const;
  void set_minimize_core(bool value);

  // optional int32 restart_running_window_size = 62 [default = 50];
  bool has_restart_running_window_size() const;
  void clear_restart_running_window_size();
  static const int kRestartRunningWindowSizeFieldNumber = 62;
  ::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size() const;
  void set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional double restart_dl_average_ratio = 63 [default = 1];
  bool has_restart_dl_average_ratio() const;
  void clear_restart_dl_average_ratio();
  static const int kRestartDlAverageRatioFieldNumber = 63;
  double restart_dl_average_ratio() const;
  void set_restart_dl_average_ratio(double value);

  // optional double blocking_restart_multiplier = 66 [default = 1.4];
  bool has_blocking_restart_multiplier() const;
  void clear_blocking_restart_multiplier();
  static const int kBlockingRestartMultiplierFieldNumber = 66;
  double blocking_restart_multiplier() const;
  void set_blocking_restart_multiplier(double value);

  // optional double max_deterministic_time = 67 [default = inf];
  bool has_max_deterministic_time() const;
  void clear_max_deterministic_time();
  static const int kMaxDeterministicTimeFieldNumber = 67;
  double max_deterministic_time() const;
  void set_max_deterministic_time(double value);

  // optional int32 blocking_restart_window_size = 65 [default = 5000];
  bool has_blocking_restart_window_size() const;
  void clear_blocking_restart_window_size();
  static const int kBlockingRestartWindowSizeFieldNumber = 65;
  ::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size() const;
  void set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 presolve_bva_threshold = 73 [default = 1];
  bool has_presolve_bva_threshold() const;
  void clear_presolve_bva_threshold();
  static const int kPresolveBvaThresholdFieldNumber = 73;
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold() const;
  void set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional double restart_lbd_average_ratio = 71 [default = 1];
  bool has_restart_lbd_average_ratio() const;
  void clear_restart_lbd_average_ratio();
  static const int kRestartLbdAverageRatioFieldNumber = 71;
  double restart_lbd_average_ratio() const;
  void set_restart_lbd_average_ratio(double value);

  // optional bool find_multiple_cores = 84 [default = true];
  bool has_find_multiple_cores() const;
  void clear_find_multiple_cores();
  static const int kFindMultipleCoresFieldNumber = 84;
  bool find_multiple_cores() const;
  void set_find_multiple_cores(bool value);

  // optional bool cover_optimization = 89 [default = true];
  bool has_cover_optimization() const;
  void clear_cover_optimization();
  static const int kCoverOptimizationFieldNumber = 89;
  bool cover_optimization() const;
  void set_cover_optimization(bool value);

  // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  bool has_use_precedences_in_disjunctive_constraint() const;
  void clear_use_precedences_in_disjunctive_constraint();
  static const int kUsePrecedencesInDisjunctiveConstraintFieldNumber = 74;
  bool use_precedences_in_disjunctive_constraint() const;
  void set_use_precedences_in_disjunctive_constraint(bool value);

  // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  bool has_use_disjunctive_constraint_in_cumulative_constraint() const;
  void clear_use_disjunctive_constraint_in_cumulative_constraint();
  static const int kUseDisjunctiveConstraintInCumulativeConstraintFieldNumber = 80;
  bool use_disjunctive_constraint_in_cumulative_constraint() const;
  void set_use_disjunctive_constraint_in_cumulative_constraint(bool value);

  // optional int32 linearization_level = 90 [default = 1];
  bool has_linearization_level() const;
  void clear_linearization_level();
  static const int kLinearizationLevelFieldNumber = 90;
  ::PROTOBUF_NAMESPACE_ID::int32 linearization_level() const;
  void set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 max_num_cuts = 91 [default = 5000];
  bool has_max_num_cuts() const;
  void clear_max_num_cuts();
  static const int kMaxNumCutsFieldNumber = 91;
  ::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts() const;
  void set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  bool has_minimize_with_propagation_restart_period() const;
  void clear_minimize_with_propagation_restart_period();
  static const int kMinimizeWithPropagationRestartPeriodFieldNumber = 96;
  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period() const;
  void set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  bool has_minimize_with_propagation_num_decisions() const;
  void clear_minimize_with_propagation_num_decisions();
  static const int kMinimizeWithPropagationNumDecisionsFieldNumber = 97;
  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions() const;
  void set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 binary_search_num_conflicts = 99 [default = -1];
  bool has_binary_search_num_conflicts() const;
  void clear_binary_search_num_conflicts();
  static const int kBinarySearchNumConflictsFieldNumber = 99;
  ::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts() const;
  void set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int32 num_search_workers = 100 [default = 1];
  bool has_num_search_workers() const;
  void clear_num_search_workers();
  static const int kNumSearchWorkersFieldNumber = 100;
  ::PROTOBUF_NAMESPACE_ID::int32 num_search_workers() const;
  void set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool exploit_all_lp_solution = 116 [default = true];
  bool has_exploit_all_lp_solution() const;
  void clear_exploit_all_lp_solution();
  static const int kExploitAllLpSolutionFieldNumber = 116;
  bool exploit_all_lp_solution() const;
  void set_exploit_all_lp_solution(bool value);

  // optional bool exploit_objective = 131 [default = true];
  bool has_exploit_objective() const;
  void clear_exploit_objective();
  static const int kExploitObjectiveFieldNumber = 131;
  bool exploit_objective() const;
  void set_exploit_objective(bool value);

  // optional bool cp_model_presolve = 86 [default = true];
  bool has_cp_model_presolve() const;
  void clear_cp_model_presolve();
  static const int kCpModelPresolveFieldNumber = 86;
  bool cp_model_presolve() const;
  void set_cp_model_presolve(bool value);

  // optional bool cp_model_use_sat_presolve = 93 [default = true];
  bool has_cp_model_use_sat_presolve() const;
  void clear_cp_model_use_sat_presolve();
  static const int kCpModelUseSatPresolveFieldNumber = 93;
  bool cp_model_use_sat_presolve() const;
  void set_cp_model_use_sat_presolve(bool value);

  // optional int32 boolean_encoding_level = 107 [default = 1];
  bool has_boolean_encoding_level() const;
  void clear_boolean_encoding_level();
  static const int kBooleanEncodingLevelFieldNumber = 107;
  ::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level() const;
  void set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool instantiate_all_variables = 106 [default = true];
  bool has_instantiate_all_variables() const;
  void clear_instantiate_all_variables();
  static const int kInstantiateAllVariablesFieldNumber = 106;
  bool instantiate_all_variables() const;
  void set_instantiate_all_variables(bool value);

  // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  bool has_auto_detect_greater_than_at_least_one_of() const;
  void clear_auto_detect_greater_than_at_least_one_of();
  static const int kAutoDetectGreaterThanAtLeastOneOfFieldNumber = 95;
  bool auto_detect_greater_than_at_least_one_of() const;
  void set_auto_detect_greater_than_at_least_one_of(bool value);

  // optional bool share_objective_bounds = 113 [default = true];
  bool has_share_objective_bounds() const;
  void clear_share_objective_bounds();
  static const int kShareObjectiveBoundsFieldNumber = 113;
  bool share_objective_bounds() const;
  void set_share_objective_bounds(bool value);

  // optional bool share_level_zero_bounds = 114 [default = true];
  bool has_share_level_zero_bounds() const;
  void clear_share_level_zero_bounds();
  static const int kShareLevelZeroBoundsFieldNumber = 114;
  bool share_level_zero_bounds() const;
  void set_share_level_zero_bounds(bool value);

  // optional int32 cp_model_probing_level = 110 [default = 2];
  bool has_cp_model_probing_level() const;
  void clear_cp_model_probing_level();
  static const int kCpModelProbingLevelFieldNumber = 110;
  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level() const;
  void set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool add_mir_cuts = 120 [default = true];
  bool has_add_mir_cuts() const;
  void clear_add_mir_cuts();
  static const int kAddMirCutsFieldNumber = 120;
  bool add_mir_cuts() const;
  void set_add_mir_cuts(bool value);

  // optional bool use_mir_rounding = 118 [default = true];
  bool has_use_mir_rounding() const;
  void clear_use_mir_rounding();
  static const int kUseMirRoundingFieldNumber = 118;
  bool use_mir_rounding() const;
  void set_use_mir_rounding(bool value);

  // optional bool add_lp_constraints_lazily = 112 [default = true];
  bool has_add_lp_constraints_lazily() const;
  void clear_add_lp_constraints_lazily();
  static const int kAddLpConstraintsLazilyFieldNumber = 112;
  bool add_lp_constraints_lazily() const;
  void set_add_lp_constraints_lazily(bool value);

  // optional bool exploit_integer_lp_solution = 94 [default = true];
  bool has_exploit_integer_lp_solution() const;
  void clear_exploit_integer_lp_solution();
  static const int kExploitIntegerLpSolutionFieldNumber = 94;
  bool exploit_integer_lp_solution() const;
  void set_exploit_integer_lp_solution(bool value);

  // optional int32 max_integer_rounding_scaling = 119 [default = 600];
  bool has_max_integer_rounding_scaling() const;
  void clear_max_integer_rounding_scaling();
  static const int kMaxIntegerRoundingScalingFieldNumber = 119;
  ::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling() const;
  void set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool use_rins_lns = 129 [default = true];
  bool has_use_rins_lns() const;
  void clear_use_rins_lns();
  static const int kUseRinsLnsFieldNumber = 129;
  bool use_rins_lns() const;
  void set_use_rins_lns(bool value);

  // optional bool use_optional_variables = 108 [default = true];
  bool has_use_optional_variables() const;
  void clear_use_optional_variables();
  static const int kUseOptionalVariablesFieldNumber = 108;
  bool use_optional_variables() const;
  void set_use_optional_variables(bool value);

  // optional bool use_exact_lp_reason = 109 [default = true];
  bool has_use_exact_lp_reason() const;
  void clear_use_exact_lp_reason();
  static const int kUseExactLpReasonFieldNumber = 109;
  bool use_exact_lp_reason() const;
  void set_use_exact_lp_reason(bool value);

  // optional bool catch_sigint_signal = 135 [default = true];
  bool has_catch_sigint_signal() const;
  void clear_catch_sigint_signal();
  static const int kCatchSigintSignalFieldNumber = 135;
  bool catch_sigint_signal() const;
  void set_catch_sigint_signal(bool value);

  // optional int64 max_inactive_count = 121 [default = 1000];
  bool has_max_inactive_count() const;
  void clear_max_inactive_count();
  static const int kMaxInactiveCountFieldNumber = 121;
  ::PROTOBUF_NAMESPACE_ID::int64 max_inactive_count() const;
  void set_max_inactive_count(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 constraint_removal_batch_size = 122 [default = 100];
  bool has_constraint_removal_batch_size() const;
  void clear_constraint_removal_batch_size();
  static const int kConstraintRemovalBatchSizeFieldNumber = 122;
  ::PROTOBUF_NAMESPACE_ID::int64 constraint_removal_batch_size() const;
  void set_constraint_removal_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  bool has_pseudo_cost_reliability_threshold() const;
  void clear_pseudo_cost_reliability_threshold();
  static const int kPseudoCostReliabilityThresholdFieldNumber = 123;
  ::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold() const;
  void set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional double mip_max_bound = 124 [default = 10000000];
  bool has_mip_max_bound() const;
  void clear_mip_max_bound();
  static const int kMipMaxBoundFieldNumber = 124;
  double mip_max_bound() const;
  void set_mip_max_bound(double value);

  // optional double mip_var_scaling = 125 [default = 1];
  bool has_mip_var_scaling() const;
  void clear_mip_var_scaling();
  static const int kMipVarScalingFieldNumber = 125;
  double mip_var_scaling() const;
  void set_mip_var_scaling(double value);

  // optional double mip_wanted_precision = 126 [default = 1e-06];
  bool has_mip_wanted_precision() const;
  void clear_mip_wanted_precision();
  static const int kMipWantedPrecisionFieldNumber = 126;
  double mip_wanted_precision() const;
  void set_mip_wanted_precision(double value);

  // optional double mip_check_precision = 128 [default = 0.0001];
  bool has_mip_check_precision() const;
  void clear_mip_check_precision();
  static const int kMipCheckPrecisionFieldNumber = 128;
  double mip_check_precision() const;
  void set_mip_check_precision(double value);

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<4> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> restart_algorithms_;
  public:
  static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> _i_give_permission_to_break_this_code_default_default_restart_algorithms_;
  private:
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_restart_algorithms_;
  int preferred_variable_order_;
  int max_sat_assumption_order_;
  double random_branches_ratio_;
  double random_polarity_ratio_;
  bool use_pb_resolution_;
  bool minimize_reduction_during_pb_resolution_;
  bool max_sat_reverse_assumption_order_;
  bool use_overload_checker_in_cumulative_constraint_;
  int clause_cleanup_protection_;
  int clause_cleanup_ordering_;
  bool use_erwa_heuristic_;
  bool also_bump_variables_in_conflict_reasons_;
  bool use_blocking_restart_;
  bool log_search_progress_;
  double strategy_change_increase_ratio_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes_;
  int search_branching_;
  double initial_variables_activity_;
  bool exploit_best_solution_;
  bool optimize_with_core_;
  bool optimize_with_max_hs_;
  bool enumerate_all_solutions_;
  bool use_timetable_edge_finding_in_cumulative_constraint_;
  bool only_add_cuts_at_level_zero_;
  bool add_knapsack_cuts_;
  bool add_cg_cuts_;
  ::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance_;
  double min_orthogonality_for_lp_constraints_;
  bool use_lns_only_;
  bool lns_focus_on_decision_variables_;
  bool randomize_search_;
  bool use_combined_no_overlap_;
  bool fill_tightened_domains_in_response_;
  bool stop_after_first_solution_;
  bool interleave_search_;
  bool deterministic_parallel_search_;
  ::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent_;
  int initial_polarity_;
  int minimization_algorithm_;
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period_;
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target_;
  double variable_activity_decay_;
  double max_variable_activity_value_;
  double clause_activity_decay_;
  double max_clause_activity_value_;
  double glucose_max_decay_;
  double glucose_decay_increment_;
  ::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period_;
  ::PROTOBUF_NAMESPACE_ID::int32 restart_period_;
  ::PROTOBUF_NAMESPACE_ID::int32 random_seed_;
  int binary_minimization_algorithm_;
  double max_time_in_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts_;
  ::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb_;
  bool use_phase_saving_;
  bool subsumption_during_conflict_analysis_;
  bool treat_binary_clauses_separately_;
  bool count_assumption_levels_in_lbd_;
  ::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment_;
  double pb_cleanup_ratio_;
  int max_sat_stratification_;
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold_;
  double presolve_probing_deterministic_time_limit_;
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight_;
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound_;
  bool presolve_blocked_clause_;
  bool presolve_use_bva_;
  bool use_optimization_hints_;
  bool minimize_core_;
  ::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size_;
  double restart_dl_average_ratio_;
  double blocking_restart_multiplier_;
  double max_deterministic_time_;
  ::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold_;
  double restart_lbd_average_ratio_;
  bool find_multiple_cores_;
  bool cover_optimization_;
  bool use_precedences_in_disjunctive_constraint_;
  bool use_disjunctive_constraint_in_cumulative_constraint_;
  ::PROTOBUF_NAMESPACE_ID::int32 linearization_level_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts_;
  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period_;
  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions_;
  ::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_search_workers_;
  bool exploit_all_lp_solution_;
  bool exploit_objective_;
  bool cp_model_presolve_;
  bool cp_model_use_sat_presolve_;
  ::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level_;
  bool instantiate_all_variables_;
  bool auto_detect_greater_than_at_least_one_of_;
  bool share_objective_bounds_;
  bool share_level_zero_bounds_;
  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level_;
  bool add_mir_cuts_;
  bool use_mir_rounding_;
  bool add_lp_constraints_lazily_;
  bool exploit_integer_lp_solution_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling_;
  bool use_rins_lns_;
  bool use_optional_variables_;
  bool use_exact_lp_reason_;
  bool catch_sigint_signal_;
  ::PROTOBUF_NAMESPACE_ID::int64 max_inactive_count_;
  ::PROTOBUF_NAMESPACE_ID::int64 constraint_removal_batch_size_;
  ::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold_;
  double mip_max_bound_;
  double mip_var_scaling_;
  double mip_wanted_precision_;
  double mip_check_precision_;
  friend struct ::TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto;
};
// ===================================================================


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

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

// optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
inline bool SatParameters::has_preferred_variable_order() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SatParameters::clear_preferred_variable_order() {
  preferred_variable_order_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::operations_research::sat::SatParameters_VariableOrder SatParameters::preferred_variable_order() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.preferred_variable_order)
  return static_cast< ::operations_research::sat::SatParameters_VariableOrder >(preferred_variable_order_);
}
inline void SatParameters::set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value) {
  assert(::operations_research::sat::SatParameters_VariableOrder_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  preferred_variable_order_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.preferred_variable_order)
}

// optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
inline bool SatParameters::has_initial_polarity() const {
  return (_has_bits_[1] & 0x00000040u) != 0;
}
inline void SatParameters::clear_initial_polarity() {
  initial_polarity_ = 1;
  _has_bits_[1] &= ~0x00000040u;
}
inline ::operations_research::sat::SatParameters_Polarity SatParameters::initial_polarity() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.initial_polarity)
  return static_cast< ::operations_research::sat::SatParameters_Polarity >(initial_polarity_);
}
inline void SatParameters::set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
  assert(::operations_research::sat::SatParameters_Polarity_IsValid(value));
  _has_bits_[1] |= 0x00000040u;
  initial_polarity_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.initial_polarity)
}

// optional bool use_phase_saving = 44 [default = true];
inline bool SatParameters::has_use_phase_saving() const {
  return (_has_bits_[1] & 0x00800000u) != 0;
}
inline void SatParameters::clear_use_phase_saving() {
  use_phase_saving_ = true;
  _has_bits_[1] &= ~0x00800000u;
}
inline bool SatParameters::use_phase_saving() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_phase_saving)
  return use_phase_saving_;
}
inline void SatParameters::set_use_phase_saving(bool value) {
  _has_bits_[1] |= 0x00800000u;
  use_phase_saving_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_phase_saving)
}

// optional double random_polarity_ratio = 45 [default = 0];
inline bool SatParameters::has_random_polarity_ratio() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SatParameters::clear_random_polarity_ratio() {
  random_polarity_ratio_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline double SatParameters::random_polarity_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_polarity_ratio)
  return random_polarity_ratio_;
}
inline void SatParameters::set_random_polarity_ratio(double value) {
  _has_bits_[0] |= 0x00000010u;
  random_polarity_ratio_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_polarity_ratio)
}

// optional double random_branches_ratio = 32 [default = 0];
inline bool SatParameters::has_random_branches_ratio() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SatParameters::clear_random_branches_ratio() {
  random_branches_ratio_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double SatParameters::random_branches_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_branches_ratio)
  return random_branches_ratio_;
}
inline void SatParameters::set_random_branches_ratio(double value) {
  _has_bits_[0] |= 0x00000008u;
  random_branches_ratio_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_branches_ratio)
}

// optional bool use_erwa_heuristic = 75 [default = false];
inline bool SatParameters::has_use_erwa_heuristic() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void SatParameters::clear_use_erwa_heuristic() {
  use_erwa_heuristic_ = false;
  _has_bits_[0] &= ~0x00000800u;
}
inline bool SatParameters::use_erwa_heuristic() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_erwa_heuristic)
  return use_erwa_heuristic_;
}
inline void SatParameters::set_use_erwa_heuristic(bool value) {
  _has_bits_[0] |= 0x00000800u;
  use_erwa_heuristic_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_erwa_heuristic)
}

// optional double initial_variables_activity = 76 [default = 0];
inline bool SatParameters::has_initial_variables_activity() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void SatParameters::clear_initial_variables_activity() {
  initial_variables_activity_ = 0;
  _has_bits_[0] &= ~0x00040000u;
}
inline double SatParameters::initial_variables_activity() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.initial_variables_activity)
  return initial_variables_activity_;
}
inline void SatParameters::set_initial_variables_activity(double value) {
  _has_bits_[0] |= 0x00040000u;
  initial_variables_activity_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.initial_variables_activity)
}

// optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
inline bool SatParameters::has_also_bump_variables_in_conflict_reasons() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void SatParameters::clear_also_bump_variables_in_conflict_reasons() {
  also_bump_variables_in_conflict_reasons_ = false;
  _has_bits_[0] &= ~0x00001000u;
}
inline bool SatParameters::also_bump_variables_in_conflict_reasons() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.also_bump_variables_in_conflict_reasons)
  return also_bump_variables_in_conflict_reasons_;
}
inline void SatParameters::set_also_bump_variables_in_conflict_reasons(bool value) {
  _has_bits_[0] |= 0x00001000u;
  also_bump_variables_in_conflict_reasons_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.also_bump_variables_in_conflict_reasons)
}

// optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
inline bool SatParameters::has_minimization_algorithm() const {
  return (_has_bits_[1] & 0x00000080u) != 0;
}
inline void SatParameters::clear_minimization_algorithm() {
  minimization_algorithm_ = 2;
  _has_bits_[1] &= ~0x00000080u;
}
inline ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm SatParameters::minimization_algorithm() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimization_algorithm)
  return static_cast< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm >(minimization_algorithm_);
}
inline void SatParameters::set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
  assert(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_IsValid(value));
  _has_bits_[1] |= 0x00000080u;
  minimization_algorithm_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimization_algorithm)
}

// optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
inline bool SatParameters::has_binary_minimization_algorithm() const {
  return (_has_bits_[1] & 0x00080000u) != 0;
}
inline void SatParameters::clear_binary_minimization_algorithm() {
  binary_minimization_algorithm_ = 1;
  _has_bits_[1] &= ~0x00080000u;
}
inline ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm SatParameters::binary_minimization_algorithm() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.binary_minimization_algorithm)
  return static_cast< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm >(binary_minimization_algorithm_);
}
inline void SatParameters::set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
  assert(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_IsValid(value));
  _has_bits_[1] |= 0x00080000u;
  binary_minimization_algorithm_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.binary_minimization_algorithm)
}

// optional bool subsumption_during_conflict_analysis = 56 [default = true];
inline bool SatParameters::has_subsumption_during_conflict_analysis() const {
  return (_has_bits_[1] & 0x01000000u) != 0;
}
inline void SatParameters::clear_subsumption_during_conflict_analysis() {
  subsumption_during_conflict_analysis_ = true;
  _has_bits_[1] &= ~0x01000000u;
}
inline bool SatParameters::subsumption_during_conflict_analysis() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.subsumption_during_conflict_analysis)
  return subsumption_during_conflict_analysis_;
}
inline void SatParameters::set_subsumption_during_conflict_analysis(bool value) {
  _has_bits_[1] |= 0x01000000u;
  subsumption_during_conflict_analysis_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.subsumption_during_conflict_analysis)
}

// optional int32 clause_cleanup_period = 11 [default = 10000];
inline bool SatParameters::has_clause_cleanup_period() const {
  return (_has_bits_[1] & 0x00000100u) != 0;
}
inline void SatParameters::clear_clause_cleanup_period() {
  clause_cleanup_period_ = 10000;
  _has_bits_[1] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_period() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_period)
  return clause_cleanup_period_;
}
inline void SatParameters::set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00000100u;
  clause_cleanup_period_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_period)
}

// optional int32 clause_cleanup_target = 13 [default = 10000];
inline bool SatParameters::has_clause_cleanup_target() const {
  return (_has_bits_[1] & 0x00000200u) != 0;
}
inline void SatParameters::clear_clause_cleanup_target() {
  clause_cleanup_target_ = 10000;
  _has_bits_[1] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_target() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_target)
  return clause_cleanup_target_;
}
inline void SatParameters::set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00000200u;
  clause_cleanup_target_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_target)
}

// optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
inline bool SatParameters::has_clause_cleanup_protection() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void SatParameters::clear_clause_cleanup_protection() {
  clause_cleanup_protection_ = 0;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::operations_research::sat::SatParameters_ClauseProtection SatParameters::clause_cleanup_protection() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_protection)
  return static_cast< ::operations_research::sat::SatParameters_ClauseProtection >(clause_cleanup_protection_);
}
inline void SatParameters::set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value) {
  assert(::operations_research::sat::SatParameters_ClauseProtection_IsValid(value));
  _has_bits_[0] |= 0x00000200u;
  clause_cleanup_protection_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_protection)
}

// optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
inline bool SatParameters::has_clause_cleanup_lbd_bound() const {
  return (_has_bits_[2] & 0x00000002u) != 0;
}
inline void SatParameters::clear_clause_cleanup_lbd_bound() {
  clause_cleanup_lbd_bound_ = 5;
  _has_bits_[2] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_lbd_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_lbd_bound)
  return clause_cleanup_lbd_bound_;
}
inline void SatParameters::set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000002u;
  clause_cleanup_lbd_bound_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_lbd_bound)
}

// optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
inline bool SatParameters::has_clause_cleanup_ordering() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void SatParameters::clear_clause_cleanup_ordering() {
  clause_cleanup_ordering_ = 0;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::operations_research::sat::SatParameters_ClauseOrdering SatParameters::clause_cleanup_ordering() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_ordering)
  return static_cast< ::operations_research::sat::SatParameters_ClauseOrdering >(clause_cleanup_ordering_);
}
inline void SatParameters::set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
  assert(::operations_research::sat::SatParameters_ClauseOrdering_IsValid(value));
  _has_bits_[0] |= 0x00000400u;
  clause_cleanup_ordering_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_ordering)
}

// optional int32 pb_cleanup_increment = 46 [default = 200];
inline bool SatParameters::has_pb_cleanup_increment() const {
  return (_has_bits_[1] & 0x08000000u) != 0;
}
inline void SatParameters::clear_pb_cleanup_increment() {
  pb_cleanup_increment_ = 200;
  _has_bits_[1] &= ~0x08000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::pb_cleanup_increment() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pb_cleanup_increment)
  return pb_cleanup_increment_;
}
inline void SatParameters::set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x08000000u;
  pb_cleanup_increment_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pb_cleanup_increment)
}

// optional double pb_cleanup_ratio = 47 [default = 0.5];
inline bool SatParameters::has_pb_cleanup_ratio() const {
  return (_has_bits_[1] & 0x10000000u) != 0;
}
inline void SatParameters::clear_pb_cleanup_ratio() {
  pb_cleanup_ratio_ = 0.5;
  _has_bits_[1] &= ~0x10000000u;
}
inline double SatParameters::pb_cleanup_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pb_cleanup_ratio)
  return pb_cleanup_ratio_;
}
inline void SatParameters::set_pb_cleanup_ratio(double value) {
  _has_bits_[1] |= 0x10000000u;
  pb_cleanup_ratio_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pb_cleanup_ratio)
}

// optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
inline bool SatParameters::has_minimize_with_propagation_restart_period() const {
  return (_has_bits_[2] & 0x00080000u) != 0;
}
inline void SatParameters::clear_minimize_with_propagation_restart_period() {
  minimize_with_propagation_restart_period_ = 10;
  _has_bits_[2] &= ~0x00080000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::minimize_with_propagation_restart_period() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_with_propagation_restart_period)
  return minimize_with_propagation_restart_period_;
}
inline void SatParameters::set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00080000u;
  minimize_with_propagation_restart_period_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_with_propagation_restart_period)
}

// optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
inline bool SatParameters::has_minimize_with_propagation_num_decisions() const {
  return (_has_bits_[2] & 0x00100000u) != 0;
}
inline void SatParameters::clear_minimize_with_propagation_num_decisions() {
  minimize_with_propagation_num_decisions_ = 1000;
  _has_bits_[2] &= ~0x00100000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::minimize_with_propagation_num_decisions() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_with_propagation_num_decisions)
  return minimize_with_propagation_num_decisions_;
}
inline void SatParameters::set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00100000u;
  minimize_with_propagation_num_decisions_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_with_propagation_num_decisions)
}

// optional double variable_activity_decay = 15 [default = 0.8];
inline bool SatParameters::has_variable_activity_decay() const {
  return (_has_bits_[1] & 0x00000400u) != 0;
}
inline void SatParameters::clear_variable_activity_decay() {
  variable_activity_decay_ = 0.8;
  _has_bits_[1] &= ~0x00000400u;
}
inline double SatParameters::variable_activity_decay() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.variable_activity_decay)
  return variable_activity_decay_;
}
inline void SatParameters::set_variable_activity_decay(double value) {
  _has_bits_[1] |= 0x00000400u;
  variable_activity_decay_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.variable_activity_decay)
}

// optional double max_variable_activity_value = 16 [default = 1e+100];
inline bool SatParameters::has_max_variable_activity_value() const {
  return (_has_bits_[1] & 0x00000800u) != 0;
}
inline void SatParameters::clear_max_variable_activity_value() {
  max_variable_activity_value_ = 1e+100;
  _has_bits_[1] &= ~0x00000800u;
}
inline double SatParameters::max_variable_activity_value() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_variable_activity_value)
  return max_variable_activity_value_;
}
inline void SatParameters::set_max_variable_activity_value(double value) {
  _has_bits_[1] |= 0x00000800u;
  max_variable_activity_value_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_variable_activity_value)
}

// optional double glucose_max_decay = 22 [default = 0.95];
inline bool SatParameters::has_glucose_max_decay() const {
  return (_has_bits_[1] & 0x00004000u) != 0;
}
inline void SatParameters::clear_glucose_max_decay() {
  glucose_max_decay_ = 0.95;
  _has_bits_[1] &= ~0x00004000u;
}
inline double SatParameters::glucose_max_decay() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_max_decay)
  return glucose_max_decay_;
}
inline void SatParameters::set_glucose_max_decay(double value) {
  _has_bits_[1] |= 0x00004000u;
  glucose_max_decay_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_max_decay)
}

// optional double glucose_decay_increment = 23 [default = 0.01];
inline bool SatParameters::has_glucose_decay_increment() const {
  return (_has_bits_[1] & 0x00008000u) != 0;
}
inline void SatParameters::clear_glucose_decay_increment() {
  glucose_decay_increment_ = 0.01;
  _has_bits_[1] &= ~0x00008000u;
}
inline double SatParameters::glucose_decay_increment() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_decay_increment)
  return glucose_decay_increment_;
}
inline void SatParameters::set_glucose_decay_increment(double value) {
  _has_bits_[1] |= 0x00008000u;
  glucose_decay_increment_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_decay_increment)
}

// optional int32 glucose_decay_increment_period = 24 [default = 5000];
inline bool SatParameters::has_glucose_decay_increment_period() const {
  return (_has_bits_[1] & 0x00010000u) != 0;
}
inline void SatParameters::clear_glucose_decay_increment_period() {
  glucose_decay_increment_period_ = 5000;
  _has_bits_[1] &= ~0x00010000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::glucose_decay_increment_period() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_decay_increment_period)
  return glucose_decay_increment_period_;
}
inline void SatParameters::set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00010000u;
  glucose_decay_increment_period_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_decay_increment_period)
}

// optional double clause_activity_decay = 17 [default = 0.999];
inline bool SatParameters::has_clause_activity_decay() const {
  return (_has_bits_[1] & 0x00001000u) != 0;
}
inline void SatParameters::clear_clause_activity_decay() {
  clause_activity_decay_ = 0.999;
  _has_bits_[1] &= ~0x00001000u;
}
inline double SatParameters::clause_activity_decay() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_activity_decay)
  return clause_activity_decay_;
}
inline void SatParameters::set_clause_activity_decay(double value) {
  _has_bits_[1] |= 0x00001000u;
  clause_activity_decay_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_activity_decay)
}

// optional double max_clause_activity_value = 18 [default = 1e+20];
inline bool SatParameters::has_max_clause_activity_value() const {
  return (_has_bits_[1] & 0x00002000u) != 0;
}
inline void SatParameters::clear_max_clause_activity_value() {
  max_clause_activity_value_ = 1e+20;
  _has_bits_[1] &= ~0x00002000u;
}
inline double SatParameters::max_clause_activity_value() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_clause_activity_value)
  return max_clause_activity_value_;
}
inline void SatParameters::set_max_clause_activity_value(double value) {
  _has_bits_[1] |= 0x00002000u;
  max_clause_activity_value_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_clause_activity_value)
}

// repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
inline int SatParameters::restart_algorithms_size() const {
  return restart_algorithms_.size();
}
inline void SatParameters::clear_restart_algorithms() {
  restart_algorithms_.Clear();
}
inline ::operations_research::sat::SatParameters_RestartAlgorithm SatParameters::restart_algorithms(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_algorithms)
  return static_cast< ::operations_research::sat::SatParameters_RestartAlgorithm >(restart_algorithms_.Get(index));
}
inline void SatParameters::set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value) {
  assert(::operations_research::sat::SatParameters_RestartAlgorithm_IsValid(value));
  restart_algorithms_.Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_algorithms)
}
inline void SatParameters::add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value) {
  assert(::operations_research::sat::SatParameters_RestartAlgorithm_IsValid(value));
  restart_algorithms_.Add(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.restart_algorithms)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
SatParameters::restart_algorithms() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.restart_algorithms)
  return restart_algorithms_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SatParameters::mutable_restart_algorithms() {
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.restart_algorithms)
  return &restart_algorithms_;
}

// optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
inline bool SatParameters::has_default_restart_algorithms() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SatParameters::clear_default_restart_algorithms() {
  default_restart_algorithms_.ClearToDefaultNoArena(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& SatParameters::default_restart_algorithms() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.default_restart_algorithms)
  return default_restart_algorithms_.GetNoArena();
}
inline void SatParameters::set_default_restart_algorithms(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  default_restart_algorithms_.SetNoArena(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline void SatParameters::set_default_restart_algorithms(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  default_restart_algorithms_.SetNoArena(
    &::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline void SatParameters::set_default_restart_algorithms(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  default_restart_algorithms_.SetNoArena(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline void SatParameters::set_default_restart_algorithms(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  default_restart_algorithms_.SetNoArena(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline std::string* SatParameters::mutable_default_restart_algorithms() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.default_restart_algorithms)
  return default_restart_algorithms_.MutableNoArena(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get());
}
inline std::string* SatParameters::release_default_restart_algorithms() {
  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.default_restart_algorithms)
  if (!has_default_restart_algorithms()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return default_restart_algorithms_.ReleaseNonDefaultNoArena(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get());
}
inline void SatParameters::set_allocated_default_restart_algorithms(std::string* default_restart_algorithms) {
  if (default_restart_algorithms != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  default_restart_algorithms_.SetAllocatedNoArena(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), default_restart_algorithms);
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.default_restart_algorithms)
}

// optional int32 restart_period = 30 [default = 50];
inline bool SatParameters::has_restart_period() const {
  return (_has_bits_[1] & 0x00020000u) != 0;
}
inline void SatParameters::clear_restart_period() {
  restart_period_ = 50;
  _has_bits_[1] &= ~0x00020000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::restart_period() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_period)
  return restart_period_;
}
inline void SatParameters::set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00020000u;
  restart_period_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_period)
}

// optional int32 restart_running_window_size = 62 [default = 50];
inline bool SatParameters::has_restart_running_window_size() const {
  return (_has_bits_[2] & 0x00000040u) != 0;
}
inline void SatParameters::clear_restart_running_window_size() {
  restart_running_window_size_ = 50;
  _has_bits_[2] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::restart_running_window_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_running_window_size)
  return restart_running_window_size_;
}
inline void SatParameters::set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000040u;
  restart_running_window_size_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_running_window_size)
}

// optional double restart_dl_average_ratio = 63 [default = 1];
inline bool SatParameters::has_restart_dl_average_ratio() const {
  return (_has_bits_[2] & 0x00000080u) != 0;
}
inline void SatParameters::clear_restart_dl_average_ratio() {
  restart_dl_average_ratio_ = 1;
  _has_bits_[2] &= ~0x00000080u;
}
inline double SatParameters::restart_dl_average_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_dl_average_ratio)
  return restart_dl_average_ratio_;
}
inline void SatParameters::set_restart_dl_average_ratio(double value) {
  _has_bits_[2] |= 0x00000080u;
  restart_dl_average_ratio_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_dl_average_ratio)
}

// optional double restart_lbd_average_ratio = 71 [default = 1];
inline bool SatParameters::has_restart_lbd_average_ratio() const {
  return (_has_bits_[2] & 0x00001000u) != 0;
}
inline void SatParameters::clear_restart_lbd_average_ratio() {
  restart_lbd_average_ratio_ = 1;
  _has_bits_[2] &= ~0x00001000u;
}
inline double SatParameters::restart_lbd_average_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_lbd_average_ratio)
  return restart_lbd_average_ratio_;
}
inline void SatParameters::set_restart_lbd_average_ratio(double value) {
  _has_bits_[2] |= 0x00001000u;
  restart_lbd_average_ratio_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_lbd_average_ratio)
}

// optional bool use_blocking_restart = 64 [default = false];
inline bool SatParameters::has_use_blocking_restart() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void SatParameters::clear_use_blocking_restart() {
  use_blocking_restart_ = false;
  _has_bits_[0] &= ~0x00002000u;
}
inline bool SatParameters::use_blocking_restart() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_blocking_restart)
  return use_blocking_restart_;
}
inline void SatParameters::set_use_blocking_restart(bool value) {
  _has_bits_[0] |= 0x00002000u;
  use_blocking_restart_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_blocking_restart)
}

// optional int32 blocking_restart_window_size = 65 [default = 5000];
inline bool SatParameters::has_blocking_restart_window_size() const {
  return (_has_bits_[2] & 0x00000400u) != 0;
}
inline void SatParameters::clear_blocking_restart_window_size() {
  blocking_restart_window_size_ = 5000;
  _has_bits_[2] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::blocking_restart_window_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.blocking_restart_window_size)
  return blocking_restart_window_size_;
}
inline void SatParameters::set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000400u;
  blocking_restart_window_size_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.blocking_restart_window_size)
}

// optional double blocking_restart_multiplier = 66 [default = 1.4];
inline bool SatParameters::has_blocking_restart_multiplier() const {
  return (_has_bits_[2] & 0x00000100u) != 0;
}
inline void SatParameters::clear_blocking_restart_multiplier() {
  blocking_restart_multiplier_ = 1.4;
  _has_bits_[2] &= ~0x00000100u;
}
inline double SatParameters::blocking_restart_multiplier() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.blocking_restart_multiplier)
  return blocking_restart_multiplier_;
}
inline void SatParameters::set_blocking_restart_multiplier(double value) {
  _has_bits_[2] |= 0x00000100u;
  blocking_restart_multiplier_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.blocking_restart_multiplier)
}

// optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
inline bool SatParameters::has_num_conflicts_before_strategy_changes() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void SatParameters::clear_num_conflicts_before_strategy_changes() {
  num_conflicts_before_strategy_changes_ = 0;
  _has_bits_[0] &= ~0x00010000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::num_conflicts_before_strategy_changes() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_conflicts_before_strategy_changes)
  return num_conflicts_before_strategy_changes_;
}
inline void SatParameters::set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00010000u;
  num_conflicts_before_strategy_changes_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_conflicts_before_strategy_changes)
}

// optional double strategy_change_increase_ratio = 69 [default = 0];
inline bool SatParameters::has_strategy_change_increase_ratio() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void SatParameters::clear_strategy_change_increase_ratio() {
  strategy_change_increase_ratio_ = 0;
  _has_bits_[0] &= ~0x00008000u;
}
inline double SatParameters::strategy_change_increase_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.strategy_change_increase_ratio)
  return strategy_change_increase_ratio_;
}
inline void SatParameters::set_strategy_change_increase_ratio(double value) {
  _has_bits_[0] |= 0x00008000u;
  strategy_change_increase_ratio_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.strategy_change_increase_ratio)
}

// optional double max_time_in_seconds = 36 [default = inf];
inline bool SatParameters::has_max_time_in_seconds() const {
  return (_has_bits_[1] & 0x00100000u) != 0;
}
inline void SatParameters::clear_max_time_in_seconds() {
  max_time_in_seconds_ = std::numeric_limits<double>::infinity();
  _has_bits_[1] &= ~0x00100000u;
}
inline double SatParameters::max_time_in_seconds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_time_in_seconds)
  return max_time_in_seconds_;
}
inline void SatParameters::set_max_time_in_seconds(double value) {
  _has_bits_[1] |= 0x00100000u;
  max_time_in_seconds_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_time_in_seconds)
}

// optional double max_deterministic_time = 67 [default = inf];
inline bool SatParameters::has_max_deterministic_time() const {
  return (_has_bits_[2] & 0x00000200u) != 0;
}
inline void SatParameters::clear_max_deterministic_time() {
  max_deterministic_time_ = std::numeric_limits<double>::infinity();
  _has_bits_[2] &= ~0x00000200u;
}
inline double SatParameters::max_deterministic_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_deterministic_time)
  return max_deterministic_time_;
}
inline void SatParameters::set_max_deterministic_time(double value) {
  _has_bits_[2] |= 0x00000200u;
  max_deterministic_time_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_deterministic_time)
}

// optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
inline bool SatParameters::has_max_number_of_conflicts() const {
  return (_has_bits_[1] & 0x00200000u) != 0;
}
inline void SatParameters::clear_max_number_of_conflicts() {
  max_number_of_conflicts_ = PROTOBUF_LONGLONG(9223372036854775807);
  _has_bits_[1] &= ~0x00200000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::max_number_of_conflicts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_number_of_conflicts)
  return max_number_of_conflicts_;
}
inline void SatParameters::set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[1] |= 0x00200000u;
  max_number_of_conflicts_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_number_of_conflicts)
}

// optional int64 max_memory_in_mb = 40 [default = 10000];
inline bool SatParameters::has_max_memory_in_mb() const {
  return (_has_bits_[1] & 0x00400000u) != 0;
}
inline void SatParameters::clear_max_memory_in_mb() {
  max_memory_in_mb_ = PROTOBUF_LONGLONG(10000);
  _has_bits_[1] &= ~0x00400000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::max_memory_in_mb() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_memory_in_mb)
  return max_memory_in_mb_;
}
inline void SatParameters::set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[1] |= 0x00400000u;
  max_memory_in_mb_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_memory_in_mb)
}

// optional bool treat_binary_clauses_separately = 33 [default = true];
inline bool SatParameters::has_treat_binary_clauses_separately() const {
  return (_has_bits_[1] & 0x02000000u) != 0;
}
inline void SatParameters::clear_treat_binary_clauses_separately() {
  treat_binary_clauses_separately_ = true;
  _has_bits_[1] &= ~0x02000000u;
}
inline bool SatParameters::treat_binary_clauses_separately() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.treat_binary_clauses_separately)
  return treat_binary_clauses_separately_;
}
inline void SatParameters::set_treat_binary_clauses_separately(bool value) {
  _has_bits_[1] |= 0x02000000u;
  treat_binary_clauses_separately_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.treat_binary_clauses_separately)
}

// optional int32 random_seed = 31 [default = 1];
inline bool SatParameters::has_random_seed() const {
  return (_has_bits_[1] & 0x00040000u) != 0;
}
inline void SatParameters::clear_random_seed() {
  random_seed_ = 1;
  _has_bits_[1] &= ~0x00040000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::random_seed() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_seed)
  return random_seed_;
}
inline void SatParameters::set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00040000u;
  random_seed_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_seed)
}

// optional bool log_search_progress = 41 [default = false];
inline bool SatParameters::has_log_search_progress() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void SatParameters::clear_log_search_progress() {
  log_search_progress_ = false;
  _has_bits_[0] &= ~0x00004000u;
}
inline bool SatParameters::log_search_progress() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_search_progress)
  return log_search_progress_;
}
inline void SatParameters::set_log_search_progress(bool value) {
  _has_bits_[0] |= 0x00004000u;
  log_search_progress_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_search_progress)
}

// optional bool use_pb_resolution = 43 [default = false];
inline bool SatParameters::has_use_pb_resolution() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void SatParameters::clear_use_pb_resolution() {
  use_pb_resolution_ = false;
  _has_bits_[0] &= ~0x00000020u;
}
inline bool SatParameters::use_pb_resolution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_pb_resolution)
  return use_pb_resolution_;
}
inline void SatParameters::set_use_pb_resolution(bool value) {
  _has_bits_[0] |= 0x00000020u;
  use_pb_resolution_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_pb_resolution)
}

// optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
inline bool SatParameters::has_minimize_reduction_during_pb_resolution() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void SatParameters::clear_minimize_reduction_during_pb_resolution() {
  minimize_reduction_during_pb_resolution_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool SatParameters::minimize_reduction_during_pb_resolution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_reduction_during_pb_resolution)
  return minimize_reduction_during_pb_resolution_;
}
inline void SatParameters::set_minimize_reduction_during_pb_resolution(bool value) {
  _has_bits_[0] |= 0x00000040u;
  minimize_reduction_during_pb_resolution_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_reduction_during_pb_resolution)
}

// optional bool count_assumption_levels_in_lbd = 49 [default = true];
inline bool SatParameters::has_count_assumption_levels_in_lbd() const {
  return (_has_bits_[1] & 0x04000000u) != 0;
}
inline void SatParameters::clear_count_assumption_levels_in_lbd() {
  count_assumption_levels_in_lbd_ = true;
  _has_bits_[1] &= ~0x04000000u;
}
inline bool SatParameters::count_assumption_levels_in_lbd() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.count_assumption_levels_in_lbd)
  return count_assumption_levels_in_lbd_;
}
inline void SatParameters::set_count_assumption_levels_in_lbd(bool value) {
  _has_bits_[1] |= 0x04000000u;
  count_assumption_levels_in_lbd_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.count_assumption_levels_in_lbd)
}

// optional int32 presolve_bve_threshold = 54 [default = 500];
inline bool SatParameters::has_presolve_bve_threshold() const {
  return (_has_bits_[1] & 0x40000000u) != 0;
}
inline void SatParameters::clear_presolve_bve_threshold() {
  presolve_bve_threshold_ = 500;
  _has_bits_[1] &= ~0x40000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bve_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bve_threshold)
  return presolve_bve_threshold_;
}
inline void SatParameters::set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x40000000u;
  presolve_bve_threshold_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bve_threshold)
}

// optional int32 presolve_bve_clause_weight = 55 [default = 3];
inline bool SatParameters::has_presolve_bve_clause_weight() const {
  return (_has_bits_[2] & 0x00000001u) != 0;
}
inline void SatParameters::clear_presolve_bve_clause_weight() {
  presolve_bve_clause_weight_ = 3;
  _has_bits_[2] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bve_clause_weight() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bve_clause_weight)
  return presolve_bve_clause_weight_;
}
inline void SatParameters::set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000001u;
  presolve_bve_clause_weight_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bve_clause_weight)
}

// optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
inline bool SatParameters::has_presolve_probing_deterministic_time_limit() const {
  return (_has_bits_[1] & 0x80000000u) != 0;
}
inline void SatParameters::clear_presolve_probing_deterministic_time_limit() {
  presolve_probing_deterministic_time_limit_ = 30;
  _has_bits_[1] &= ~0x80000000u;
}
inline double SatParameters::presolve_probing_deterministic_time_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_probing_deterministic_time_limit)
  return presolve_probing_deterministic_time_limit_;
}
inline void SatParameters::set_presolve_probing_deterministic_time_limit(double value) {
  _has_bits_[1] |= 0x80000000u;
  presolve_probing_deterministic_time_limit_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_probing_deterministic_time_limit)
}

// optional bool presolve_blocked_clause = 88 [default = true];
inline bool SatParameters::has_presolve_blocked_clause() const {
  return (_has_bits_[2] & 0x00000004u) != 0;
}
inline void SatParameters::clear_presolve_blocked_clause() {
  presolve_blocked_clause_ = true;
  _has_bits_[2] &= ~0x00000004u;
}
inline bool SatParameters::presolve_blocked_clause() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_blocked_clause)
  return presolve_blocked_clause_;
}
inline void SatParameters::set_presolve_blocked_clause(bool value) {
  _has_bits_[2] |= 0x00000004u;
  presolve_blocked_clause_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_blocked_clause)
}

// optional bool presolve_use_bva = 72 [default = true];
inline bool SatParameters::has_presolve_use_bva() const {
  return (_has_bits_[2] & 0x00000008u) != 0;
}
inline void SatParameters::clear_presolve_use_bva() {
  presolve_use_bva_ = true;
  _has_bits_[2] &= ~0x00000008u;
}
inline bool SatParameters::presolve_use_bva() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_use_bva)
  return presolve_use_bva_;
}
inline void SatParameters::set_presolve_use_bva(bool value) {
  _has_bits_[2] |= 0x00000008u;
  presolve_use_bva_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_use_bva)
}

// optional int32 presolve_bva_threshold = 73 [default = 1];
inline bool SatParameters::has_presolve_bva_threshold() const {
  return (_has_bits_[2] & 0x00000800u) != 0;
}
inline void SatParameters::clear_presolve_bva_threshold() {
  presolve_bva_threshold_ = 1;
  _has_bits_[2] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bva_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bva_threshold)
  return presolve_bva_threshold_;
}
inline void SatParameters::set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000800u;
  presolve_bva_threshold_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bva_threshold)
}

// optional bool use_optimization_hints = 35 [default = true];
inline bool SatParameters::has_use_optimization_hints() const {
  return (_has_bits_[2] & 0x00000010u) != 0;
}
inline void SatParameters::clear_use_optimization_hints() {
  use_optimization_hints_ = true;
  _has_bits_[2] &= ~0x00000010u;
}
inline bool SatParameters::use_optimization_hints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_optimization_hints)
  return use_optimization_hints_;
}
inline void SatParameters::set_use_optimization_hints(bool value) {
  _has_bits_[2] |= 0x00000010u;
  use_optimization_hints_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_optimization_hints)
}

// optional bool minimize_core = 50 [default = true];
inline bool SatParameters::has_minimize_core() const {
  return (_has_bits_[2] & 0x00000020u) != 0;
}
inline void SatParameters::clear_minimize_core() {
  minimize_core_ = true;
  _has_bits_[2] &= ~0x00000020u;
}
inline bool SatParameters::minimize_core() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_core)
  return minimize_core_;
}
inline void SatParameters::set_minimize_core(bool value) {
  _has_bits_[2] |= 0x00000020u;
  minimize_core_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_core)
}

// optional bool find_multiple_cores = 84 [default = true];
inline bool SatParameters::has_find_multiple_cores() const {
  return (_has_bits_[2] & 0x00002000u) != 0;
}
inline void SatParameters::clear_find_multiple_cores() {
  find_multiple_cores_ = true;
  _has_bits_[2] &= ~0x00002000u;
}
inline bool SatParameters::find_multiple_cores() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.find_multiple_cores)
  return find_multiple_cores_;
}
inline void SatParameters::set_find_multiple_cores(bool value) {
  _has_bits_[2] |= 0x00002000u;
  find_multiple_cores_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.find_multiple_cores)
}

// optional bool cover_optimization = 89 [default = true];
inline bool SatParameters::has_cover_optimization() const {
  return (_has_bits_[2] & 0x00004000u) != 0;
}
inline void SatParameters::clear_cover_optimization() {
  cover_optimization_ = true;
  _has_bits_[2] &= ~0x00004000u;
}
inline bool SatParameters::cover_optimization() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cover_optimization)
  return cover_optimization_;
}
inline void SatParameters::set_cover_optimization(bool value) {
  _has_bits_[2] |= 0x00004000u;
  cover_optimization_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cover_optimization)
}

// optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
inline bool SatParameters::has_max_sat_assumption_order() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SatParameters::clear_max_sat_assumption_order() {
  max_sat_assumption_order_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::operations_research::sat::SatParameters_MaxSatAssumptionOrder SatParameters::max_sat_assumption_order() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_assumption_order)
  return static_cast< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder >(max_sat_assumption_order_);
}
inline void SatParameters::set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value) {
  assert(::operations_research::sat::SatParameters_MaxSatAssumptionOrder_IsValid(value));
  _has_bits_[0] |= 0x00000004u;
  max_sat_assumption_order_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_assumption_order)
}

// optional bool max_sat_reverse_assumption_order = 52 [default = false];
inline bool SatParameters::has_max_sat_reverse_assumption_order() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void SatParameters::clear_max_sat_reverse_assumption_order() {
  max_sat_reverse_assumption_order_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool SatParameters::max_sat_reverse_assumption_order() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_reverse_assumption_order)
  return max_sat_reverse_assumption_order_;
}
inline void SatParameters::set_max_sat_reverse_assumption_order(bool value) {
  _has_bits_[0] |= 0x00000080u;
  max_sat_reverse_assumption_order_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_reverse_assumption_order)
}

// optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
inline bool SatParameters::has_max_sat_stratification() const {
  return (_has_bits_[1] & 0x20000000u) != 0;
}
inline void SatParameters::clear_max_sat_stratification() {
  max_sat_stratification_ = 1;
  _has_bits_[1] &= ~0x20000000u;
}
inline ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm SatParameters::max_sat_stratification() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_stratification)
  return static_cast< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm >(max_sat_stratification_);
}
inline void SatParameters::set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
  assert(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_IsValid(value));
  _has_bits_[1] |= 0x20000000u;
  max_sat_stratification_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_stratification)
}

// optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
inline bool SatParameters::has_use_precedences_in_disjunctive_constraint() const {
  return (_has_bits_[2] & 0x00008000u) != 0;
}
inline void SatParameters::clear_use_precedences_in_disjunctive_constraint() {
  use_precedences_in_disjunctive_constraint_ = true;
  _has_bits_[2] &= ~0x00008000u;
}
inline bool SatParameters::use_precedences_in_disjunctive_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_precedences_in_disjunctive_constraint)
  return use_precedences_in_disjunctive_constraint_;
}
inline void SatParameters::set_use_precedences_in_disjunctive_constraint(bool value) {
  _has_bits_[2] |= 0x00008000u;
  use_precedences_in_disjunctive_constraint_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_precedences_in_disjunctive_constraint)
}

// optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
inline bool SatParameters::has_use_overload_checker_in_cumulative_constraint() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void SatParameters::clear_use_overload_checker_in_cumulative_constraint() {
  use_overload_checker_in_cumulative_constraint_ = false;
  _has_bits_[0] &= ~0x00000100u;
}
inline bool SatParameters::use_overload_checker_in_cumulative_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_overload_checker_in_cumulative_constraint)
  return use_overload_checker_in_cumulative_constraint_;
}
inline void SatParameters::set_use_overload_checker_in_cumulative_constraint(bool value) {
  _has_bits_[0] |= 0x00000100u;
  use_overload_checker_in_cumulative_constraint_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_overload_checker_in_cumulative_constraint)
}

// optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
inline bool SatParameters::has_use_timetable_edge_finding_in_cumulative_constraint() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void SatParameters::clear_use_timetable_edge_finding_in_cumulative_constraint() {
  use_timetable_edge_finding_in_cumulative_constraint_ = false;
  _has_bits_[0] &= ~0x00800000u;
}
inline bool SatParameters::use_timetable_edge_finding_in_cumulative_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_timetable_edge_finding_in_cumulative_constraint)
  return use_timetable_edge_finding_in_cumulative_constraint_;
}
inline void SatParameters::set_use_timetable_edge_finding_in_cumulative_constraint(bool value) {
  _has_bits_[0] |= 0x00800000u;
  use_timetable_edge_finding_in_cumulative_constraint_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_timetable_edge_finding_in_cumulative_constraint)
}

// optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
inline bool SatParameters::has_use_disjunctive_constraint_in_cumulative_constraint() const {
  return (_has_bits_[2] & 0x00010000u) != 0;
}
inline void SatParameters::clear_use_disjunctive_constraint_in_cumulative_constraint() {
  use_disjunctive_constraint_in_cumulative_constraint_ = true;
  _has_bits_[2] &= ~0x00010000u;
}
inline bool SatParameters::use_disjunctive_constraint_in_cumulative_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_disjunctive_constraint_in_cumulative_constraint)
  return use_disjunctive_constraint_in_cumulative_constraint_;
}
inline void SatParameters::set_use_disjunctive_constraint_in_cumulative_constraint(bool value) {
  _has_bits_[2] |= 0x00010000u;
  use_disjunctive_constraint_in_cumulative_constraint_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_disjunctive_constraint_in_cumulative_constraint)
}

// optional int32 linearization_level = 90 [default = 1];
inline bool SatParameters::has_linearization_level() const {
  return (_has_bits_[2] & 0x00020000u) != 0;
}
inline void SatParameters::clear_linearization_level() {
  linearization_level_ = 1;
  _has_bits_[2] &= ~0x00020000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::linearization_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.linearization_level)
  return linearization_level_;
}
inline void SatParameters::set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00020000u;
  linearization_level_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.linearization_level)
}

// optional int32 boolean_encoding_level = 107 [default = 1];
inline bool SatParameters::has_boolean_encoding_level() const {
  return (_has_bits_[2] & 0x08000000u) != 0;
}
inline void SatParameters::clear_boolean_encoding_level() {
  boolean_encoding_level_ = 1;
  _has_bits_[2] &= ~0x08000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::boolean_encoding_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.boolean_encoding_level)
  return boolean_encoding_level_;
}
inline void SatParameters::set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x08000000u;
  boolean_encoding_level_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.boolean_encoding_level)
}

// optional int32 max_num_cuts = 91 [default = 5000];
inline bool SatParameters::has_max_num_cuts() const {
  return (_has_bits_[2] & 0x00040000u) != 0;
}
inline void SatParameters::clear_max_num_cuts() {
  max_num_cuts_ = 5000;
  _has_bits_[2] &= ~0x00040000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_num_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_num_cuts)
  return max_num_cuts_;
}
inline void SatParameters::set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00040000u;
  max_num_cuts_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_num_cuts)
}

// optional bool only_add_cuts_at_level_zero = 92 [default = false];
inline bool SatParameters::has_only_add_cuts_at_level_zero() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void SatParameters::clear_only_add_cuts_at_level_zero() {
  only_add_cuts_at_level_zero_ = false;
  _has_bits_[0] &= ~0x01000000u;
}
inline bool SatParameters::only_add_cuts_at_level_zero() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.only_add_cuts_at_level_zero)
  return only_add_cuts_at_level_zero_;
}
inline void SatParameters::set_only_add_cuts_at_level_zero(bool value) {
  _has_bits_[0] |= 0x01000000u;
  only_add_cuts_at_level_zero_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.only_add_cuts_at_level_zero)
}

// optional bool add_knapsack_cuts = 111 [default = false];
inline bool SatParameters::has_add_knapsack_cuts() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void SatParameters::clear_add_knapsack_cuts() {
  add_knapsack_cuts_ = false;
  _has_bits_[0] &= ~0x02000000u;
}
inline bool SatParameters::add_knapsack_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_knapsack_cuts)
  return add_knapsack_cuts_;
}
inline void SatParameters::set_add_knapsack_cuts(bool value) {
  _has_bits_[0] |= 0x02000000u;
  add_knapsack_cuts_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_knapsack_cuts)
}

// optional bool add_cg_cuts = 117 [default = false];
inline bool SatParameters::has_add_cg_cuts() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void SatParameters::clear_add_cg_cuts() {
  add_cg_cuts_ = false;
  _has_bits_[0] &= ~0x04000000u;
}
inline bool SatParameters::add_cg_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_cg_cuts)
  return add_cg_cuts_;
}
inline void SatParameters::set_add_cg_cuts(bool value) {
  _has_bits_[0] |= 0x04000000u;
  add_cg_cuts_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_cg_cuts)
}

// optional bool add_mir_cuts = 120 [default = true];
inline bool SatParameters::has_add_mir_cuts() const {
  return (_has_bits_[3] & 0x00000002u) != 0;
}
inline void SatParameters::clear_add_mir_cuts() {
  add_mir_cuts_ = true;
  _has_bits_[3] &= ~0x00000002u;
}
inline bool SatParameters::add_mir_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_mir_cuts)
  return add_mir_cuts_;
}
inline void SatParameters::set_add_mir_cuts(bool value) {
  _has_bits_[3] |= 0x00000002u;
  add_mir_cuts_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_mir_cuts)
}

// optional bool use_mir_rounding = 118 [default = true];
inline bool SatParameters::has_use_mir_rounding() const {
  return (_has_bits_[3] & 0x00000004u) != 0;
}
inline void SatParameters::clear_use_mir_rounding() {
  use_mir_rounding_ = true;
  _has_bits_[3] &= ~0x00000004u;
}
inline bool SatParameters::use_mir_rounding() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_mir_rounding)
  return use_mir_rounding_;
}
inline void SatParameters::set_use_mir_rounding(bool value) {
  _has_bits_[3] |= 0x00000004u;
  use_mir_rounding_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_mir_rounding)
}

// optional int32 max_integer_rounding_scaling = 119 [default = 600];
inline bool SatParameters::has_max_integer_rounding_scaling() const {
  return (_has_bits_[3] & 0x00000020u) != 0;
}
inline void SatParameters::clear_max_integer_rounding_scaling() {
  max_integer_rounding_scaling_ = 600;
  _has_bits_[3] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_integer_rounding_scaling() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_integer_rounding_scaling)
  return max_integer_rounding_scaling_;
}
inline void SatParameters::set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00000020u;
  max_integer_rounding_scaling_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_integer_rounding_scaling)
}

// optional bool add_lp_constraints_lazily = 112 [default = true];
inline bool SatParameters::has_add_lp_constraints_lazily() const {
  return (_has_bits_[3] & 0x00000008u) != 0;
}
inline void SatParameters::clear_add_lp_constraints_lazily() {
  add_lp_constraints_lazily_ = true;
  _has_bits_[3] &= ~0x00000008u;
}
inline bool SatParameters::add_lp_constraints_lazily() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_lp_constraints_lazily)
  return add_lp_constraints_lazily_;
}
inline void SatParameters::set_add_lp_constraints_lazily(bool value) {
  _has_bits_[3] |= 0x00000008u;
  add_lp_constraints_lazily_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_lp_constraints_lazily)
}

// optional double min_orthogonality_for_lp_constraints = 115 [default = 0];
inline bool SatParameters::has_min_orthogonality_for_lp_constraints() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void SatParameters::clear_min_orthogonality_for_lp_constraints() {
  min_orthogonality_for_lp_constraints_ = 0;
  _has_bits_[0] &= ~0x10000000u;
}
inline double SatParameters::min_orthogonality_for_lp_constraints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
  return min_orthogonality_for_lp_constraints_;
}
inline void SatParameters::set_min_orthogonality_for_lp_constraints(double value) {
  _has_bits_[0] |= 0x10000000u;
  min_orthogonality_for_lp_constraints_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
}

// optional int64 max_inactive_count = 121 [default = 1000];
inline bool SatParameters::has_max_inactive_count() const {
  return (_has_bits_[3] & 0x00000400u) != 0;
}
inline void SatParameters::clear_max_inactive_count() {
  max_inactive_count_ = PROTOBUF_LONGLONG(1000);
  _has_bits_[3] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::max_inactive_count() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_inactive_count)
  return max_inactive_count_;
}
inline void SatParameters::set_max_inactive_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[3] |= 0x00000400u;
  max_inactive_count_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_inactive_count)
}

// optional int64 constraint_removal_batch_size = 122 [default = 100];
inline bool SatParameters::has_constraint_removal_batch_size() const {
  return (_has_bits_[3] & 0x00000800u) != 0;
}
inline void SatParameters::clear_constraint_removal_batch_size() {
  constraint_removal_batch_size_ = PROTOBUF_LONGLONG(100);
  _has_bits_[3] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::constraint_removal_batch_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.constraint_removal_batch_size)
  return constraint_removal_batch_size_;
}
inline void SatParameters::set_constraint_removal_batch_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[3] |= 0x00000800u;
  constraint_removal_batch_size_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.constraint_removal_batch_size)
}

// optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
inline bool SatParameters::has_search_branching() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void SatParameters::clear_search_branching() {
  search_branching_ = 0;
  _has_bits_[0] &= ~0x00020000u;
}
inline ::operations_research::sat::SatParameters_SearchBranching SatParameters::search_branching() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.search_branching)
  return static_cast< ::operations_research::sat::SatParameters_SearchBranching >(search_branching_);
}
inline void SatParameters::set_search_branching(::operations_research::sat::SatParameters_SearchBranching value) {
  assert(::operations_research::sat::SatParameters_SearchBranching_IsValid(value));
  _has_bits_[0] |= 0x00020000u;
  search_branching_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.search_branching)
}

// optional bool exploit_integer_lp_solution = 94 [default = true];
inline bool SatParameters::has_exploit_integer_lp_solution() const {
  return (_has_bits_[3] & 0x00000010u) != 0;
}
inline void SatParameters::clear_exploit_integer_lp_solution() {
  exploit_integer_lp_solution_ = true;
  _has_bits_[3] &= ~0x00000010u;
}
inline bool SatParameters::exploit_integer_lp_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_integer_lp_solution)
  return exploit_integer_lp_solution_;
}
inline void SatParameters::set_exploit_integer_lp_solution(bool value) {
  _has_bits_[3] |= 0x00000010u;
  exploit_integer_lp_solution_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_integer_lp_solution)
}

// optional bool exploit_all_lp_solution = 116 [default = true];
inline bool SatParameters::has_exploit_all_lp_solution() const {
  return (_has_bits_[2] & 0x00800000u) != 0;
}
inline void SatParameters::clear_exploit_all_lp_solution() {
  exploit_all_lp_solution_ = true;
  _has_bits_[2] &= ~0x00800000u;
}
inline bool SatParameters::exploit_all_lp_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_all_lp_solution)
  return exploit_all_lp_solution_;
}
inline void SatParameters::set_exploit_all_lp_solution(bool value) {
  _has_bits_[2] |= 0x00800000u;
  exploit_all_lp_solution_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_all_lp_solution)
}

// optional bool exploit_best_solution = 130 [default = false];
inline bool SatParameters::has_exploit_best_solution() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void SatParameters::clear_exploit_best_solution() {
  exploit_best_solution_ = false;
  _has_bits_[0] &= ~0x00080000u;
}
inline bool SatParameters::exploit_best_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_best_solution)
  return exploit_best_solution_;
}
inline void SatParameters::set_exploit_best_solution(bool value) {
  _has_bits_[0] |= 0x00080000u;
  exploit_best_solution_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_best_solution)
}

// optional bool exploit_objective = 131 [default = true];
inline bool SatParameters::has_exploit_objective() const {
  return (_has_bits_[2] & 0x01000000u) != 0;
}
inline void SatParameters::clear_exploit_objective() {
  exploit_objective_ = true;
  _has_bits_[2] &= ~0x01000000u;
}
inline bool SatParameters::exploit_objective() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_objective)
  return exploit_objective_;
}
inline void SatParameters::set_exploit_objective(bool value) {
  _has_bits_[2] |= 0x01000000u;
  exploit_objective_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_objective)
}

// optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
inline bool SatParameters::has_pseudo_cost_reliability_threshold() const {
  return (_has_bits_[3] & 0x00001000u) != 0;
}
inline void SatParameters::clear_pseudo_cost_reliability_threshold() {
  pseudo_cost_reliability_threshold_ = PROTOBUF_LONGLONG(100);
  _has_bits_[3] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::pseudo_cost_reliability_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pseudo_cost_reliability_threshold)
  return pseudo_cost_reliability_threshold_;
}
inline void SatParameters::set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[3] |= 0x00001000u;
  pseudo_cost_reliability_threshold_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pseudo_cost_reliability_threshold)
}

// optional bool optimize_with_core = 83 [default = false];
inline bool SatParameters::has_optimize_with_core() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void SatParameters::clear_optimize_with_core() {
  optimize_with_core_ = false;
  _has_bits_[0] &= ~0x00100000u;
}
inline bool SatParameters::optimize_with_core() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_core)
  return optimize_with_core_;
}
inline void SatParameters::set_optimize_with_core(bool value) {
  _has_bits_[0] |= 0x00100000u;
  optimize_with_core_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_core)
}

// optional int32 binary_search_num_conflicts = 99 [default = -1];
inline bool SatParameters::has_binary_search_num_conflicts() const {
  return (_has_bits_[2] & 0x00200000u) != 0;
}
inline void SatParameters::clear_binary_search_num_conflicts() {
  binary_search_num_conflicts_ = -1;
  _has_bits_[2] &= ~0x00200000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::binary_search_num_conflicts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.binary_search_num_conflicts)
  return binary_search_num_conflicts_;
}
inline void SatParameters::set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00200000u;
  binary_search_num_conflicts_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.binary_search_num_conflicts)
}

// optional bool optimize_with_max_hs = 85 [default = false];
inline bool SatParameters::has_optimize_with_max_hs() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void SatParameters::clear_optimize_with_max_hs() {
  optimize_with_max_hs_ = false;
  _has_bits_[0] &= ~0x00200000u;
}
inline bool SatParameters::optimize_with_max_hs() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_max_hs)
  return optimize_with_max_hs_;
}
inline void SatParameters::set_optimize_with_max_hs(bool value) {
  _has_bits_[0] |= 0x00200000u;
  optimize_with_max_hs_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_max_hs)
}

// optional bool cp_model_presolve = 86 [default = true];
inline bool SatParameters::has_cp_model_presolve() const {
  return (_has_bits_[2] & 0x02000000u) != 0;
}
inline void SatParameters::clear_cp_model_presolve() {
  cp_model_presolve_ = true;
  _has_bits_[2] &= ~0x02000000u;
}
inline bool SatParameters::cp_model_presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_presolve)
  return cp_model_presolve_;
}
inline void SatParameters::set_cp_model_presolve(bool value) {
  _has_bits_[2] |= 0x02000000u;
  cp_model_presolve_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_presolve)
}

// optional int32 cp_model_probing_level = 110 [default = 2];
inline bool SatParameters::has_cp_model_probing_level() const {
  return (_has_bits_[3] & 0x00000001u) != 0;
}
inline void SatParameters::clear_cp_model_probing_level() {
  cp_model_probing_level_ = 2;
  _has_bits_[3] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cp_model_probing_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_probing_level)
  return cp_model_probing_level_;
}
inline void SatParameters::set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00000001u;
  cp_model_probing_level_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_probing_level)
}

// optional bool cp_model_use_sat_presolve = 93 [default = true];
inline bool SatParameters::has_cp_model_use_sat_presolve() const {
  return (_has_bits_[2] & 0x04000000u) != 0;
}
inline void SatParameters::clear_cp_model_use_sat_presolve() {
  cp_model_use_sat_presolve_ = true;
  _has_bits_[2] &= ~0x04000000u;
}
inline bool SatParameters::cp_model_use_sat_presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
  return cp_model_use_sat_presolve_;
}
inline void SatParameters::set_cp_model_use_sat_presolve(bool value) {
  _has_bits_[2] |= 0x04000000u;
  cp_model_use_sat_presolve_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
}

// optional bool enumerate_all_solutions = 87 [default = false];
inline bool SatParameters::has_enumerate_all_solutions() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void SatParameters::clear_enumerate_all_solutions() {
  enumerate_all_solutions_ = false;
  _has_bits_[0] &= ~0x00400000u;
}
inline bool SatParameters::enumerate_all_solutions() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.enumerate_all_solutions)
  return enumerate_all_solutions_;
}
inline void SatParameters::set_enumerate_all_solutions(bool value) {
  _has_bits_[0] |= 0x00400000u;
  enumerate_all_solutions_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.enumerate_all_solutions)
}

// optional bool fill_tightened_domains_in_response = 132 [default = false];
inline bool SatParameters::has_fill_tightened_domains_in_response() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void SatParameters::clear_fill_tightened_domains_in_response() {
  fill_tightened_domains_in_response_ = false;
  _has_bits_[1] &= ~0x00000002u;
}
inline bool SatParameters::fill_tightened_domains_in_response() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fill_tightened_domains_in_response)
  return fill_tightened_domains_in_response_;
}
inline void SatParameters::set_fill_tightened_domains_in_response(bool value) {
  _has_bits_[1] |= 0x00000002u;
  fill_tightened_domains_in_response_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fill_tightened_domains_in_response)
}

// optional bool instantiate_all_variables = 106 [default = true];
inline bool SatParameters::has_instantiate_all_variables() const {
  return (_has_bits_[2] & 0x10000000u) != 0;
}
inline void SatParameters::clear_instantiate_all_variables() {
  instantiate_all_variables_ = true;
  _has_bits_[2] &= ~0x10000000u;
}
inline bool SatParameters::instantiate_all_variables() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.instantiate_all_variables)
  return instantiate_all_variables_;
}
inline void SatParameters::set_instantiate_all_variables(bool value) {
  _has_bits_[2] |= 0x10000000u;
  instantiate_all_variables_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.instantiate_all_variables)
}

// optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
inline bool SatParameters::has_auto_detect_greater_than_at_least_one_of() const {
  return (_has_bits_[2] & 0x20000000u) != 0;
}
inline void SatParameters::clear_auto_detect_greater_than_at_least_one_of() {
  auto_detect_greater_than_at_least_one_of_ = true;
  _has_bits_[2] &= ~0x20000000u;
}
inline bool SatParameters::auto_detect_greater_than_at_least_one_of() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.auto_detect_greater_than_at_least_one_of)
  return auto_detect_greater_than_at_least_one_of_;
}
inline void SatParameters::set_auto_detect_greater_than_at_least_one_of(bool value) {
  _has_bits_[2] |= 0x20000000u;
  auto_detect_greater_than_at_least_one_of_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.auto_detect_greater_than_at_least_one_of)
}

// optional bool stop_after_first_solution = 98 [default = false];
inline bool SatParameters::has_stop_after_first_solution() const {
  return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void SatParameters::clear_stop_after_first_solution() {
  stop_after_first_solution_ = false;
  _has_bits_[1] &= ~0x00000004u;
}
inline bool SatParameters::stop_after_first_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.stop_after_first_solution)
  return stop_after_first_solution_;
}
inline void SatParameters::set_stop_after_first_solution(bool value) {
  _has_bits_[1] |= 0x00000004u;
  stop_after_first_solution_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_first_solution)
}

// optional int32 num_search_workers = 100 [default = 1];
inline bool SatParameters::has_num_search_workers() const {
  return (_has_bits_[2] & 0x00400000u) != 0;
}
inline void SatParameters::clear_num_search_workers() {
  num_search_workers_ = 1;
  _has_bits_[2] &= ~0x00400000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::num_search_workers() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_search_workers)
  return num_search_workers_;
}
inline void SatParameters::set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00400000u;
  num_search_workers_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_search_workers)
}

// optional bool interleave_search = 136 [default = false];
inline bool SatParameters::has_interleave_search() const {
  return (_has_bits_[1] & 0x00000008u) != 0;
}
inline void SatParameters::clear_interleave_search() {
  interleave_search_ = false;
  _has_bits_[1] &= ~0x00000008u;
}
inline bool SatParameters::interleave_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.interleave_search)
  return interleave_search_;
}
inline void SatParameters::set_interleave_search(bool value) {
  _has_bits_[1] |= 0x00000008u;
  interleave_search_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_search)
}

// optional bool deterministic_parallel_search = 134 [default = false];
inline bool SatParameters::has_deterministic_parallel_search() const {
  return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void SatParameters::clear_deterministic_parallel_search() {
  deterministic_parallel_search_ = false;
  _has_bits_[1] &= ~0x00000010u;
}
inline bool SatParameters::deterministic_parallel_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.deterministic_parallel_search)
  return deterministic_parallel_search_;
}
inline void SatParameters::set_deterministic_parallel_search(bool value) {
  _has_bits_[1] |= 0x00000010u;
  deterministic_parallel_search_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.deterministic_parallel_search)
}

// optional bool share_objective_bounds = 113 [default = true];
inline bool SatParameters::has_share_objective_bounds() const {
  return (_has_bits_[2] & 0x40000000u) != 0;
}
inline void SatParameters::clear_share_objective_bounds() {
  share_objective_bounds_ = true;
  _has_bits_[2] &= ~0x40000000u;
}
inline bool SatParameters::share_objective_bounds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_objective_bounds)
  return share_objective_bounds_;
}
inline void SatParameters::set_share_objective_bounds(bool value) {
  _has_bits_[2] |= 0x40000000u;
  share_objective_bounds_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_objective_bounds)
}

// optional bool share_level_zero_bounds = 114 [default = true];
inline bool SatParameters::has_share_level_zero_bounds() const {
  return (_has_bits_[2] & 0x80000000u) != 0;
}
inline void SatParameters::clear_share_level_zero_bounds() {
  share_level_zero_bounds_ = true;
  _has_bits_[2] &= ~0x80000000u;
}
inline bool SatParameters::share_level_zero_bounds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_level_zero_bounds)
  return share_level_zero_bounds_;
}
inline void SatParameters::set_share_level_zero_bounds(bool value) {
  _has_bits_[2] |= 0x80000000u;
  share_level_zero_bounds_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_level_zero_bounds)
}

// optional bool use_lns_only = 101 [default = false];
inline bool SatParameters::has_use_lns_only() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void SatParameters::clear_use_lns_only() {
  use_lns_only_ = false;
  _has_bits_[0] &= ~0x20000000u;
}
inline bool SatParameters::use_lns_only() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_lns_only)
  return use_lns_only_;
}
inline void SatParameters::set_use_lns_only(bool value) {
  _has_bits_[0] |= 0x20000000u;
  use_lns_only_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_lns_only)
}

// optional bool lns_focus_on_decision_variables = 105 [default = false];
inline bool SatParameters::has_lns_focus_on_decision_variables() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void SatParameters::clear_lns_focus_on_decision_variables() {
  lns_focus_on_decision_variables_ = false;
  _has_bits_[0] &= ~0x40000000u;
}
inline bool SatParameters::lns_focus_on_decision_variables() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lns_focus_on_decision_variables)
  return lns_focus_on_decision_variables_;
}
inline void SatParameters::set_lns_focus_on_decision_variables(bool value) {
  _has_bits_[0] |= 0x40000000u;
  lns_focus_on_decision_variables_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lns_focus_on_decision_variables)
}

// optional bool use_rins_lns = 129 [default = true];
inline bool SatParameters::has_use_rins_lns() const {
  return (_has_bits_[3] & 0x00000040u) != 0;
}
inline void SatParameters::clear_use_rins_lns() {
  use_rins_lns_ = true;
  _has_bits_[3] &= ~0x00000040u;
}
inline bool SatParameters::use_rins_lns() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_rins_lns)
  return use_rins_lns_;
}
inline void SatParameters::set_use_rins_lns(bool value) {
  _has_bits_[3] |= 0x00000040u;
  use_rins_lns_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_rins_lns)
}

// optional bool randomize_search = 103 [default = false];
inline bool SatParameters::has_randomize_search() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void SatParameters::clear_randomize_search() {
  randomize_search_ = false;
  _has_bits_[0] &= ~0x80000000u;
}
inline bool SatParameters::randomize_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.randomize_search)
  return randomize_search_;
}
inline void SatParameters::set_randomize_search(bool value) {
  _has_bits_[0] |= 0x80000000u;
  randomize_search_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.randomize_search)
}

// optional int64 search_randomization_tolerance = 104 [default = 0];
inline bool SatParameters::has_search_randomization_tolerance() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void SatParameters::clear_search_randomization_tolerance() {
  search_randomization_tolerance_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x08000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::search_randomization_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.search_randomization_tolerance)
  return search_randomization_tolerance_;
}
inline void SatParameters::set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x08000000u;
  search_randomization_tolerance_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.search_randomization_tolerance)
}

// optional bool use_optional_variables = 108 [default = true];
inline bool SatParameters::has_use_optional_variables() const {
  return (_has_bits_[3] & 0x00000080u) != 0;
}
inline void SatParameters::clear_use_optional_variables() {
  use_optional_variables_ = true;
  _has_bits_[3] &= ~0x00000080u;
}
inline bool SatParameters::use_optional_variables() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_optional_variables)
  return use_optional_variables_;
}
inline void SatParameters::set_use_optional_variables(bool value) {
  _has_bits_[3] |= 0x00000080u;
  use_optional_variables_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_optional_variables)
}

// optional bool use_exact_lp_reason = 109 [default = true];
inline bool SatParameters::has_use_exact_lp_reason() const {
  return (_has_bits_[3] & 0x00000100u) != 0;
}
inline void SatParameters::clear_use_exact_lp_reason() {
  use_exact_lp_reason_ = true;
  _has_bits_[3] &= ~0x00000100u;
}
inline bool SatParameters::use_exact_lp_reason() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_exact_lp_reason)
  return use_exact_lp_reason_;
}
inline void SatParameters::set_use_exact_lp_reason(bool value) {
  _has_bits_[3] |= 0x00000100u;
  use_exact_lp_reason_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_exact_lp_reason)
}

// optional bool use_combined_no_overlap = 133 [default = false];
inline bool SatParameters::has_use_combined_no_overlap() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void SatParameters::clear_use_combined_no_overlap() {
  use_combined_no_overlap_ = false;
  _has_bits_[1] &= ~0x00000001u;
}
inline bool SatParameters::use_combined_no_overlap() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_combined_no_overlap)
  return use_combined_no_overlap_;
}
inline void SatParameters::set_use_combined_no_overlap(bool value) {
  _has_bits_[1] |= 0x00000001u;
  use_combined_no_overlap_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_combined_no_overlap)
}

// optional double mip_max_bound = 124 [default = 10000000];
inline bool SatParameters::has_mip_max_bound() const {
  return (_has_bits_[3] & 0x00002000u) != 0;
}
inline void SatParameters::clear_mip_max_bound() {
  mip_max_bound_ = 10000000;
  _has_bits_[3] &= ~0x00002000u;
}
inline double SatParameters::mip_max_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_max_bound)
  return mip_max_bound_;
}
inline void SatParameters::set_mip_max_bound(double value) {
  _has_bits_[3] |= 0x00002000u;
  mip_max_bound_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_bound)
}

// optional double mip_var_scaling = 125 [default = 1];
inline bool SatParameters::has_mip_var_scaling() const {
  return (_has_bits_[3] & 0x00004000u) != 0;
}
inline void SatParameters::clear_mip_var_scaling() {
  mip_var_scaling_ = 1;
  _has_bits_[3] &= ~0x00004000u;
}
inline double SatParameters::mip_var_scaling() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_var_scaling)
  return mip_var_scaling_;
}
inline void SatParameters::set_mip_var_scaling(double value) {
  _has_bits_[3] |= 0x00004000u;
  mip_var_scaling_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_var_scaling)
}

// optional double mip_wanted_precision = 126 [default = 1e-06];
inline bool SatParameters::has_mip_wanted_precision() const {
  return (_has_bits_[3] & 0x00008000u) != 0;
}
inline void SatParameters::clear_mip_wanted_precision() {
  mip_wanted_precision_ = 1e-06;
  _has_bits_[3] &= ~0x00008000u;
}
inline double SatParameters::mip_wanted_precision() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_wanted_precision)
  return mip_wanted_precision_;
}
inline void SatParameters::set_mip_wanted_precision(double value) {
  _has_bits_[3] |= 0x00008000u;
  mip_wanted_precision_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_wanted_precision)
}

// optional int32 mip_max_activity_exponent = 127 [default = 53];
inline bool SatParameters::has_mip_max_activity_exponent() const {
  return (_has_bits_[1] & 0x00000020u) != 0;
}
inline void SatParameters::clear_mip_max_activity_exponent() {
  mip_max_activity_exponent_ = 53;
  _has_bits_[1] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::mip_max_activity_exponent() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_max_activity_exponent)
  return mip_max_activity_exponent_;
}
inline void SatParameters::set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00000020u;
  mip_max_activity_exponent_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_activity_exponent)
}

// optional double mip_check_precision = 128 [default = 0.0001];
inline bool SatParameters::has_mip_check_precision() const {
  return (_has_bits_[3] & 0x00010000u) != 0;
}
inline void SatParameters::clear_mip_check_precision() {
  mip_check_precision_ = 0.0001;
  _has_bits_[3] &= ~0x00010000u;
}
inline double SatParameters::mip_check_precision() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_check_precision)
  return mip_check_precision_;
}
inline void SatParameters::set_mip_check_precision(double value) {
  _has_bits_[3] |= 0x00010000u;
  mip_check_precision_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_check_precision)
}

// optional bool catch_sigint_signal = 135 [default = true];
inline bool SatParameters::has_catch_sigint_signal() const {
  return (_has_bits_[3] & 0x00000200u) != 0;
}
inline void SatParameters::clear_catch_sigint_signal() {
  catch_sigint_signal_ = true;
  _has_bits_[3] &= ~0x00000200u;
}
inline bool SatParameters::catch_sigint_signal() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.catch_sigint_signal)
  return catch_sigint_signal_;
}
inline void SatParameters::set_catch_sigint_signal(bool value) {
  _has_bits_[3] |= 0x00000200u;
  catch_sigint_signal_ = value;
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.catch_sigint_signal)
}

#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::SatParameters_VariableOrder> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_VariableOrder>() {
  return ::operations_research::sat::SatParameters_VariableOrder_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_Polarity> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_Polarity>() {
  return ::operations_research::sat::SatParameters_Polarity_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm>() {
  return ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm>() {
  return ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ClauseProtection> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ClauseProtection>() {
  return ::operations_research::sat::SatParameters_ClauseProtection_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ClauseOrdering> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ClauseOrdering>() {
  return ::operations_research::sat::SatParameters_ClauseOrdering_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_RestartAlgorithm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_RestartAlgorithm>() {
  return ::operations_research::sat::SatParameters_RestartAlgorithm_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder>() {
  return ::operations_research::sat::SatParameters_MaxSatAssumptionOrder_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm>() {
  return ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_descriptor();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_SearchBranching> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_SearchBranching>() {
  return ::operations_research::sat::SatParameters_SearchBranching_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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