// 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 < 3012000
#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 3012002 < 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_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_ortools_2fsat_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);
}
enum SatParameters_FPRoundingMethod : int {
  SatParameters_FPRoundingMethod_NEAREST_INTEGER = 0,
  SatParameters_FPRoundingMethod_LOCK_BASED = 1,
  SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED = 3,
  SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED = 2
};
bool SatParameters_FPRoundingMethod_IsValid(int value);
constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MIN = SatParameters_FPRoundingMethod_NEAREST_INTEGER;
constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MAX = SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED;
constexpr int SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE = SatParameters_FPRoundingMethod_FPRoundingMethod_MAX + 1;

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

class SatParameters PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.SatParameters) */ {
 public:
  inline SatParameters() : SatParameters(nullptr) {};
  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 (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

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

  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;

  friend void swap(SatParameters& a, SatParameters& b) {
    a.Swap(&b);
  }
  inline void Swap(SatParameters* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SatParameters* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // 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;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) 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";
  }
  protected:
  explicit SatParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  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);
  }

  typedef SatParameters_FPRoundingMethod FPRoundingMethod;
  static constexpr FPRoundingMethod NEAREST_INTEGER =
    SatParameters_FPRoundingMethod_NEAREST_INTEGER;
  static constexpr FPRoundingMethod LOCK_BASED =
    SatParameters_FPRoundingMethod_LOCK_BASED;
  static constexpr FPRoundingMethod ACTIVE_LOCK_BASED =
    SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED;
  static constexpr FPRoundingMethod PROPAGATION_ASSISTED =
    SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED;
  static inline bool FPRoundingMethod_IsValid(int value) {
    return SatParameters_FPRoundingMethod_IsValid(value);
  }
  static constexpr FPRoundingMethod FPRoundingMethod_MIN =
    SatParameters_FPRoundingMethod_FPRoundingMethod_MIN;
  static constexpr FPRoundingMethod FPRoundingMethod_MAX =
    SatParameters_FPRoundingMethod_FPRoundingMethod_MAX;
  static constexpr int FPRoundingMethod_ARRAYSIZE =
    SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  FPRoundingMethod_descriptor() {
    return SatParameters_FPRoundingMethod_descriptor();
  }
  template<typename T>
  static inline const std::string& FPRoundingMethod_Name(T enum_t_value) {
    static_assert(::std::is_same<T, FPRoundingMethod>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function FPRoundingMethod_Name.");
    return SatParameters_FPRoundingMethod_Name(enum_t_value);
  }
  static inline bool FPRoundingMethod_Parse(const std::string& name,
      FPRoundingMethod* value) {
    return SatParameters_FPRoundingMethod_Parse(name, value);
  }

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

  enum : int {
    kRestartAlgorithmsFieldNumber = 61,
    kDefaultRestartAlgorithmsFieldNumber = 70,
    kPreferredVariableOrderFieldNumber = 1,
    kMaxSatAssumptionOrderFieldNumber = 51,
    kRandomBranchesRatioFieldNumber = 32,
    kRandomPolarityRatioFieldNumber = 45,
    kClauseCleanupProtectionFieldNumber = 58,
    kClauseCleanupOrderingFieldNumber = 60,
    kUseErwaHeuristicFieldNumber = 75,
    kAlsoBumpVariablesInConflictReasonsFieldNumber = 77,
    kUseBlockingRestartFieldNumber = 64,
    kLogSearchProgressFieldNumber = 41,
    kNumConflictsBeforeStrategyChangesFieldNumber = 68,
    kStrategyChangeIncreaseRatioFieldNumber = 69,
    kInitialVariablesActivityFieldNumber = 76,
    kMaxSatReverseAssumptionOrderFieldNumber = 52,
    kUseOverloadCheckerInCumulativeConstraintFieldNumber = 78,
    kUseTimetableEdgeFindingInCumulativeConstraintFieldNumber = 79,
    kOnlyAddCutsAtLevelZeroFieldNumber = 92,
    kSearchBranchingFieldNumber = 82,
    kOptimizeWithMaxHsFieldNumber = 85,
    kEnumerateAllSolutionsFieldNumber = 87,
    kFillTightenedDomainsInResponseFieldNumber = 132,
    kStopAfterFirstSolutionFieldNumber = 98,
    kUsePbResolutionFieldNumber = 43,
    kMinimizeReductionDuringPbResolutionFieldNumber = 48,
    kCpModelPostsolveWithFullSolverFieldNumber = 162,
    kUseSatInprocessingFieldNumber = 163,
    kSearchRandomizationToleranceFieldNumber = 104,
    kAddKnapsackCutsFieldNumber = 111,
    kExploitBestSolutionFieldNumber = 130,
    kExploitRelaxationSolutionFieldNumber = 161,
    kOptimizeWithCoreFieldNumber = 83,
    kLnsFocusOnDecisionVariablesFieldNumber = 105,
    kUseRelaxationLnsFieldNumber = 150,
    kDiversifyLnsParamsFieldNumber = 137,
    kRandomizeSearchFieldNumber = 103,
    kStopAfterPresolveFieldNumber = 149,
    kInterleaveSearchFieldNumber = 136,
    kReduceMemoryUsageInInterleaveModeFieldNumber = 141,
    kUseLnsOnlyFieldNumber = 101,
    kUseBranchingInLpFieldNumber = 139,
    kUseCombinedNoOverlapFieldNumber = 133,
    kProbingPeriodAtRootFieldNumber = 142,
    kCpModelMaxNumPresolveOperationsFieldNumber = 151,
    kAbsoluteGapLimitFieldNumber = 159,
    kRelativeGapLimitFieldNumber = 160,
    kFpRoundingFieldNumber = 165,
    kInitialPolarityFieldNumber = 2,
    kMinimizationAlgorithmFieldNumber = 4,
    kClauseCleanupPeriodFieldNumber = 11,
    kClauseCleanupTargetFieldNumber = 13,
    kVariableActivityDecayFieldNumber = 15,
    kMaxVariableActivityValueFieldNumber = 16,
    kClauseActivityDecayFieldNumber = 17,
    kMaxClauseActivityValueFieldNumber = 18,
    kGlucoseMaxDecayFieldNumber = 22,
    kGlucoseDecayIncrementFieldNumber = 23,
    kGlucoseDecayIncrementPeriodFieldNumber = 24,
    kRestartPeriodFieldNumber = 30,
    kRandomSeedFieldNumber = 31,
    kBinaryMinimizationAlgorithmFieldNumber = 34,
    kMaxTimeInSecondsFieldNumber = 36,
    kMaxNumberOfConflictsFieldNumber = 37,
    kMaxMemoryInMbFieldNumber = 40,
    kUsePhaseSavingFieldNumber = 44,
    kSubsumptionDuringConflictAnalysisFieldNumber = 56,
    kTreatBinaryClausesSeparatelyFieldNumber = 33,
    kCountAssumptionLevelsInLbdFieldNumber = 49,
    kPbCleanupIncrementFieldNumber = 46,
    kPbCleanupRatioFieldNumber = 47,
    kMaxSatStratificationFieldNumber = 53,
    kPresolveBveThresholdFieldNumber = 54,
    kPresolveProbingDeterministicTimeLimitFieldNumber = 57,
    kPresolveBveClauseWeightFieldNumber = 55,
    kClauseCleanupLbdBoundFieldNumber = 59,
    kRestartDlAverageRatioFieldNumber = 63,
    kRestartRunningWindowSizeFieldNumber = 62,
    kBlockingRestartWindowSizeFieldNumber = 65,
    kBlockingRestartMultiplierFieldNumber = 66,
    kMaxDeterministicTimeFieldNumber = 67,
    kRestartLbdAverageRatioFieldNumber = 71,
    kPresolveBvaThresholdFieldNumber = 73,
    kMinimizeCoreFieldNumber = 50,
    kFindMultipleCoresFieldNumber = 84,
    kCoverOptimizationFieldNumber = 89,
    kUsePrecedencesInDisjunctiveConstraintFieldNumber = 74,
    kPresolveBlockedClauseFieldNumber = 88,
    kPresolveUseBvaFieldNumber = 72,
    kCpModelPresolveFieldNumber = 86,
    kCpModelUseSatPresolveFieldNumber = 93,
    kLinearizationLevelFieldNumber = 90,
    kMaxNumCutsFieldNumber = 91,
    kMinimizeWithPropagationRestartPeriodFieldNumber = 96,
    kMinimizeWithPropagationNumDecisionsFieldNumber = 97,
    kBinarySearchNumConflictsFieldNumber = 99,
    kNumSearchWorkersFieldNumber = 100,
    kBooleanEncodingLevelFieldNumber = 107,
    kInstantiateAllVariablesFieldNumber = 106,
    kAutoDetectGreaterThanAtLeastOneOfFieldNumber = 95,
    kShareObjectiveBoundsFieldNumber = 113,
    kShareLevelZeroBoundsFieldNumber = 114,
    kCpModelProbingLevelFieldNumber = 110,
    kMinOrthogonalityForLpConstraintsFieldNumber = 115,
    kAddLpConstraintsLazilyFieldNumber = 112,
    kExploitIntegerLpSolutionFieldNumber = 94,
    kExploitAllLpSolutionFieldNumber = 116,
    kExploitObjectiveFieldNumber = 131,
    kUseDisjunctiveConstraintInCumulativeConstraintFieldNumber = 80,
    kAddCgCutsFieldNumber = 117,
    kAddMirCutsFieldNumber = 120,
    kAddLinMaxCutsFieldNumber = 152,
    kMaxIntegerRoundingScalingFieldNumber = 119,
    kExpandElementConstraintsFieldNumber = 140,
    kExpandAutomatonConstraintsFieldNumber = 143,
    kExpandTableConstraintsFieldNumber = 158,
    kUseOptimizationHintsFieldNumber = 35,
    kMaxConsecutiveInactiveCountFieldNumber = 121,
    kNewConstraintsBatchSizeFieldNumber = 122,
    kPseudoCostReliabilityThresholdFieldNumber = 123,
    kMipMaxBoundFieldNumber = 124,
    kMipVarScalingFieldNumber = 125,
    kMipWantedPrecisionFieldNumber = 126,
    kMipMaxActivityExponentFieldNumber = 127,
    kUseRinsLnsFieldNumber = 129,
    kUseFeasibilityPumpFieldNumber = 164,
    kUseOptionalVariablesFieldNumber = 108,
    kUseExactLpReasonFieldNumber = 109,
    kMipCheckPrecisionFieldNumber = 128,
    kInterleaveBatchSizeFieldNumber = 134,
    kMaxPresolveIterationsFieldNumber = 138,
    kMergeNoOverlapWorkLimitFieldNumber = 145,
    kMergeAtMostOneWorkLimitFieldNumber = 146,
    kPresolveSubstitutionLevelFieldNumber = 147,
    kMaxAllDiffCutSizeFieldNumber = 148,
    kCatchSigintSignalFieldNumber = 135,
    kUseImpliedBoundsFieldNumber = 144,
    kMipAutomaticallyScaleVariablesFieldNumber = 166,
    kHintConflictLimitFieldNumber = 153,
    kCutMaxActiveCountValueFieldNumber = 155,
    kMaxCutRoundsAtLevelZeroFieldNumber = 154,
    kCutCleanupTargetFieldNumber = 157,
    kCutActiveCountDecayFieldNumber = 156,
  };
  // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  int restart_algorithms_size() const;
  private:
  int _internal_restart_algorithms_size() const;
  public:
  void clear_restart_algorithms();
  private:
  ::operations_research::sat::SatParameters_RestartAlgorithm _internal_restart_algorithms(int index) const;
  void _internal_add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_restart_algorithms();
  public:
  ::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;
  private:
  bool _internal_has_default_restart_algorithms() const;
  public:
  void clear_default_restart_algorithms();
  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);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_default_restart_algorithms();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_default_restart_algorithms(
      std::string* default_restart_algorithms);
  private:
  const std::string& _internal_default_restart_algorithms() const;
  void _internal_set_default_restart_algorithms(const std::string& value);
  std::string* _internal_mutable_default_restart_algorithms();
  public:

  // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  bool has_preferred_variable_order() const;
  private:
  bool _internal_has_preferred_variable_order() const;
  public:
  void clear_preferred_variable_order();
  ::operations_research::sat::SatParameters_VariableOrder preferred_variable_order() const;
  void set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value);
  private:
  ::operations_research::sat::SatParameters_VariableOrder _internal_preferred_variable_order() const;
  void _internal_set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value);
  public:

  // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  bool has_max_sat_assumption_order() const;
  private:
  bool _internal_has_max_sat_assumption_order() const;
  public:
  void clear_max_sat_assumption_order();
  ::operations_research::sat::SatParameters_MaxSatAssumptionOrder max_sat_assumption_order() const;
  void set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value);
  private:
  ::operations_research::sat::SatParameters_MaxSatAssumptionOrder _internal_max_sat_assumption_order() const;
  void _internal_set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value);
  public:

  // optional double random_branches_ratio = 32 [default = 0];
  bool has_random_branches_ratio() const;
  private:
  bool _internal_has_random_branches_ratio() const;
  public:
  void clear_random_branches_ratio();
  double random_branches_ratio() const;
  void set_random_branches_ratio(double value);
  private:
  double _internal_random_branches_ratio() const;
  void _internal_set_random_branches_ratio(double value);
  public:

  // optional double random_polarity_ratio = 45 [default = 0];
  bool has_random_polarity_ratio() const;
  private:
  bool _internal_has_random_polarity_ratio() const;
  public:
  void clear_random_polarity_ratio();
  double random_polarity_ratio() const;
  void set_random_polarity_ratio(double value);
  private:
  double _internal_random_polarity_ratio() const;
  void _internal_set_random_polarity_ratio(double value);
  public:

  // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  bool has_clause_cleanup_protection() const;
  private:
  bool _internal_has_clause_cleanup_protection() const;
  public:
  void clear_clause_cleanup_protection();
  ::operations_research::sat::SatParameters_ClauseProtection clause_cleanup_protection() const;
  void set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value);
  private:
  ::operations_research::sat::SatParameters_ClauseProtection _internal_clause_cleanup_protection() const;
  void _internal_set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value);
  public:

  // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  bool has_clause_cleanup_ordering() const;
  private:
  bool _internal_has_clause_cleanup_ordering() const;
  public:
  void clear_clause_cleanup_ordering();
  ::operations_research::sat::SatParameters_ClauseOrdering clause_cleanup_ordering() const;
  void set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value);
  private:
  ::operations_research::sat::SatParameters_ClauseOrdering _internal_clause_cleanup_ordering() const;
  void _internal_set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value);
  public:

  // optional bool use_erwa_heuristic = 75 [default = false];
  bool has_use_erwa_heuristic() const;
  private:
  bool _internal_has_use_erwa_heuristic() const;
  public:
  void clear_use_erwa_heuristic();
  bool use_erwa_heuristic() const;
  void set_use_erwa_heuristic(bool value);
  private:
  bool _internal_use_erwa_heuristic() const;
  void _internal_set_use_erwa_heuristic(bool value);
  public:

  // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  bool has_also_bump_variables_in_conflict_reasons() const;
  private:
  bool _internal_has_also_bump_variables_in_conflict_reasons() const;
  public:
  void clear_also_bump_variables_in_conflict_reasons();
  bool also_bump_variables_in_conflict_reasons() const;
  void set_also_bump_variables_in_conflict_reasons(bool value);
  private:
  bool _internal_also_bump_variables_in_conflict_reasons() const;
  void _internal_set_also_bump_variables_in_conflict_reasons(bool value);
  public:

  // optional bool use_blocking_restart = 64 [default = false];
  bool has_use_blocking_restart() const;
  private:
  bool _internal_has_use_blocking_restart() const;
  public:
  void clear_use_blocking_restart();
  bool use_blocking_restart() const;
  void set_use_blocking_restart(bool value);
  private:
  bool _internal_use_blocking_restart() const;
  void _internal_set_use_blocking_restart(bool value);
  public:

  // optional bool log_search_progress = 41 [default = false];
  bool has_log_search_progress() const;
  private:
  bool _internal_has_log_search_progress() const;
  public:
  void clear_log_search_progress();
  bool log_search_progress() const;
  void set_log_search_progress(bool value);
  private:
  bool _internal_log_search_progress() const;
  void _internal_set_log_search_progress(bool value);
  public:

  // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  bool has_num_conflicts_before_strategy_changes() const;
  private:
  bool _internal_has_num_conflicts_before_strategy_changes() const;
  public:
  void clear_num_conflicts_before_strategy_changes();
  ::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes() const;
  void set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_conflicts_before_strategy_changes() const;
  void _internal_set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double strategy_change_increase_ratio = 69 [default = 0];
  bool has_strategy_change_increase_ratio() const;
  private:
  bool _internal_has_strategy_change_increase_ratio() const;
  public:
  void clear_strategy_change_increase_ratio();
  double strategy_change_increase_ratio() const;
  void set_strategy_change_increase_ratio(double value);
  private:
  double _internal_strategy_change_increase_ratio() const;
  void _internal_set_strategy_change_increase_ratio(double value);
  public:

  // optional double initial_variables_activity = 76 [default = 0];
  bool has_initial_variables_activity() const;
  private:
  bool _internal_has_initial_variables_activity() const;
  public:
  void clear_initial_variables_activity();
  double initial_variables_activity() const;
  void set_initial_variables_activity(double value);
  private:
  double _internal_initial_variables_activity() const;
  void _internal_set_initial_variables_activity(double value);
  public:

  // optional bool max_sat_reverse_assumption_order = 52 [default = false];
  bool has_max_sat_reverse_assumption_order() const;
  private:
  bool _internal_has_max_sat_reverse_assumption_order() const;
  public:
  void clear_max_sat_reverse_assumption_order();
  bool max_sat_reverse_assumption_order() const;
  void set_max_sat_reverse_assumption_order(bool value);
  private:
  bool _internal_max_sat_reverse_assumption_order() const;
  void _internal_set_max_sat_reverse_assumption_order(bool value);
  public:

  // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  bool has_use_overload_checker_in_cumulative_constraint() const;
  private:
  bool _internal_has_use_overload_checker_in_cumulative_constraint() const;
  public:
  void clear_use_overload_checker_in_cumulative_constraint();
  bool use_overload_checker_in_cumulative_constraint() const;
  void set_use_overload_checker_in_cumulative_constraint(bool value);
  private:
  bool _internal_use_overload_checker_in_cumulative_constraint() const;
  void _internal_set_use_overload_checker_in_cumulative_constraint(bool value);
  public:

  // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  bool has_use_timetable_edge_finding_in_cumulative_constraint() const;
  private:
  bool _internal_has_use_timetable_edge_finding_in_cumulative_constraint() const;
  public:
  void clear_use_timetable_edge_finding_in_cumulative_constraint();
  bool use_timetable_edge_finding_in_cumulative_constraint() const;
  void set_use_timetable_edge_finding_in_cumulative_constraint(bool value);
  private:
  bool _internal_use_timetable_edge_finding_in_cumulative_constraint() const;
  void _internal_set_use_timetable_edge_finding_in_cumulative_constraint(bool value);
  public:

  // optional bool only_add_cuts_at_level_zero = 92 [default = false];
  bool has_only_add_cuts_at_level_zero() const;
  private:
  bool _internal_has_only_add_cuts_at_level_zero() const;
  public:
  void clear_only_add_cuts_at_level_zero();
  bool only_add_cuts_at_level_zero() const;
  void set_only_add_cuts_at_level_zero(bool value);
  private:
  bool _internal_only_add_cuts_at_level_zero() const;
  void _internal_set_only_add_cuts_at_level_zero(bool value);
  public:

  // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  bool has_search_branching() const;
  private:
  bool _internal_has_search_branching() const;
  public:
  void clear_search_branching();
  ::operations_research::sat::SatParameters_SearchBranching search_branching() const;
  void set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);
  private:
  ::operations_research::sat::SatParameters_SearchBranching _internal_search_branching() const;
  void _internal_set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);
  public:

  // optional bool optimize_with_max_hs = 85 [default = false];
  bool has_optimize_with_max_hs() const;
  private:
  bool _internal_has_optimize_with_max_hs() const;
  public:
  void clear_optimize_with_max_hs();
  bool optimize_with_max_hs() const;
  void set_optimize_with_max_hs(bool value);
  private:
  bool _internal_optimize_with_max_hs() const;
  void _internal_set_optimize_with_max_hs(bool value);
  public:

  // optional bool enumerate_all_solutions = 87 [default = false];
  bool has_enumerate_all_solutions() const;
  private:
  bool _internal_has_enumerate_all_solutions() const;
  public:
  void clear_enumerate_all_solutions();
  bool enumerate_all_solutions() const;
  void set_enumerate_all_solutions(bool value);
  private:
  bool _internal_enumerate_all_solutions() const;
  void _internal_set_enumerate_all_solutions(bool value);
  public:

  // optional bool fill_tightened_domains_in_response = 132 [default = false];
  bool has_fill_tightened_domains_in_response() const;
  private:
  bool _internal_has_fill_tightened_domains_in_response() const;
  public:
  void clear_fill_tightened_domains_in_response();
  bool fill_tightened_domains_in_response() const;
  void set_fill_tightened_domains_in_response(bool value);
  private:
  bool _internal_fill_tightened_domains_in_response() const;
  void _internal_set_fill_tightened_domains_in_response(bool value);
  public:

  // optional bool stop_after_first_solution = 98 [default = false];
  bool has_stop_after_first_solution() const;
  private:
  bool _internal_has_stop_after_first_solution() const;
  public:
  void clear_stop_after_first_solution();
  bool stop_after_first_solution() const;
  void set_stop_after_first_solution(bool value);
  private:
  bool _internal_stop_after_first_solution() const;
  void _internal_set_stop_after_first_solution(bool value);
  public:

  // optional bool use_pb_resolution = 43 [default = false];
  bool has_use_pb_resolution() const;
  private:
  bool _internal_has_use_pb_resolution() const;
  public:
  void clear_use_pb_resolution();
  bool use_pb_resolution() const;
  void set_use_pb_resolution(bool value);
  private:
  bool _internal_use_pb_resolution() const;
  void _internal_set_use_pb_resolution(bool value);
  public:

  // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  bool has_minimize_reduction_during_pb_resolution() const;
  private:
  bool _internal_has_minimize_reduction_during_pb_resolution() const;
  public:
  void clear_minimize_reduction_during_pb_resolution();
  bool minimize_reduction_during_pb_resolution() const;
  void set_minimize_reduction_during_pb_resolution(bool value);
  private:
  bool _internal_minimize_reduction_during_pb_resolution() const;
  void _internal_set_minimize_reduction_during_pb_resolution(bool value);
  public:

  // optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
  bool has_cp_model_postsolve_with_full_solver() const;
  private:
  bool _internal_has_cp_model_postsolve_with_full_solver() const;
  public:
  void clear_cp_model_postsolve_with_full_solver();
  bool cp_model_postsolve_with_full_solver() const;
  void set_cp_model_postsolve_with_full_solver(bool value);
  private:
  bool _internal_cp_model_postsolve_with_full_solver() const;
  void _internal_set_cp_model_postsolve_with_full_solver(bool value);
  public:

  // optional bool use_sat_inprocessing = 163 [default = false];
  bool has_use_sat_inprocessing() const;
  private:
  bool _internal_has_use_sat_inprocessing() const;
  public:
  void clear_use_sat_inprocessing();
  bool use_sat_inprocessing() const;
  void set_use_sat_inprocessing(bool value);
  private:
  bool _internal_use_sat_inprocessing() const;
  void _internal_set_use_sat_inprocessing(bool value);
  public:

  // optional int64 search_randomization_tolerance = 104 [default = 0];
  bool has_search_randomization_tolerance() const;
  private:
  bool _internal_has_search_randomization_tolerance() const;
  public:
  void clear_search_randomization_tolerance();
  ::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance() const;
  void set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_search_randomization_tolerance() const;
  void _internal_set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional bool add_knapsack_cuts = 111 [default = false];
  bool has_add_knapsack_cuts() const;
  private:
  bool _internal_has_add_knapsack_cuts() const;
  public:
  void clear_add_knapsack_cuts();
  bool add_knapsack_cuts() const;
  void set_add_knapsack_cuts(bool value);
  private:
  bool _internal_add_knapsack_cuts() const;
  void _internal_set_add_knapsack_cuts(bool value);
  public:

  // optional bool exploit_best_solution = 130 [default = false];
  bool has_exploit_best_solution() const;
  private:
  bool _internal_has_exploit_best_solution() const;
  public:
  void clear_exploit_best_solution();
  bool exploit_best_solution() const;
  void set_exploit_best_solution(bool value);
  private:
  bool _internal_exploit_best_solution() const;
  void _internal_set_exploit_best_solution(bool value);
  public:

  // optional bool exploit_relaxation_solution = 161 [default = false];
  bool has_exploit_relaxation_solution() const;
  private:
  bool _internal_has_exploit_relaxation_solution() const;
  public:
  void clear_exploit_relaxation_solution();
  bool exploit_relaxation_solution() const;
  void set_exploit_relaxation_solution(bool value);
  private:
  bool _internal_exploit_relaxation_solution() const;
  void _internal_set_exploit_relaxation_solution(bool value);
  public:

  // optional bool optimize_with_core = 83 [default = false];
  bool has_optimize_with_core() const;
  private:
  bool _internal_has_optimize_with_core() const;
  public:
  void clear_optimize_with_core();
  bool optimize_with_core() const;
  void set_optimize_with_core(bool value);
  private:
  bool _internal_optimize_with_core() const;
  void _internal_set_optimize_with_core(bool value);
  public:

  // optional bool lns_focus_on_decision_variables = 105 [default = false];
  bool has_lns_focus_on_decision_variables() const;
  private:
  bool _internal_has_lns_focus_on_decision_variables() const;
  public:
  void clear_lns_focus_on_decision_variables();
  bool lns_focus_on_decision_variables() const;
  void set_lns_focus_on_decision_variables(bool value);
  private:
  bool _internal_lns_focus_on_decision_variables() const;
  void _internal_set_lns_focus_on_decision_variables(bool value);
  public:

  // optional bool use_relaxation_lns = 150 [default = false];
  bool has_use_relaxation_lns() const;
  private:
  bool _internal_has_use_relaxation_lns() const;
  public:
  void clear_use_relaxation_lns();
  bool use_relaxation_lns() const;
  void set_use_relaxation_lns(bool value);
  private:
  bool _internal_use_relaxation_lns() const;
  void _internal_set_use_relaxation_lns(bool value);
  public:

  // optional bool diversify_lns_params = 137 [default = false];
  bool has_diversify_lns_params() const;
  private:
  bool _internal_has_diversify_lns_params() const;
  public:
  void clear_diversify_lns_params();
  bool diversify_lns_params() const;
  void set_diversify_lns_params(bool value);
  private:
  bool _internal_diversify_lns_params() const;
  void _internal_set_diversify_lns_params(bool value);
  public:

  // optional bool randomize_search = 103 [default = false];
  bool has_randomize_search() const;
  private:
  bool _internal_has_randomize_search() const;
  public:
  void clear_randomize_search();
  bool randomize_search() const;
  void set_randomize_search(bool value);
  private:
  bool _internal_randomize_search() const;
  void _internal_set_randomize_search(bool value);
  public:

  // optional bool stop_after_presolve = 149 [default = false];
  bool has_stop_after_presolve() const;
  private:
  bool _internal_has_stop_after_presolve() const;
  public:
  void clear_stop_after_presolve();
  bool stop_after_presolve() const;
  void set_stop_after_presolve(bool value);
  private:
  bool _internal_stop_after_presolve() const;
  void _internal_set_stop_after_presolve(bool value);
  public:

  // optional bool interleave_search = 136 [default = false];
  bool has_interleave_search() const;
  private:
  bool _internal_has_interleave_search() const;
  public:
  void clear_interleave_search();
  bool interleave_search() const;
  void set_interleave_search(bool value);
  private:
  bool _internal_interleave_search() const;
  void _internal_set_interleave_search(bool value);
  public:

  // optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
  bool has_reduce_memory_usage_in_interleave_mode() const;
  private:
  bool _internal_has_reduce_memory_usage_in_interleave_mode() const;
  public:
  void clear_reduce_memory_usage_in_interleave_mode();
  bool reduce_memory_usage_in_interleave_mode() const;
  void set_reduce_memory_usage_in_interleave_mode(bool value);
  private:
  bool _internal_reduce_memory_usage_in_interleave_mode() const;
  void _internal_set_reduce_memory_usage_in_interleave_mode(bool value);
  public:

  // optional bool use_lns_only = 101 [default = false];
  bool has_use_lns_only() const;
  private:
  bool _internal_has_use_lns_only() const;
  public:
  void clear_use_lns_only();
  bool use_lns_only() const;
  void set_use_lns_only(bool value);
  private:
  bool _internal_use_lns_only() const;
  void _internal_set_use_lns_only(bool value);
  public:

  // optional bool use_branching_in_lp = 139 [default = false];
  bool has_use_branching_in_lp() const;
  private:
  bool _internal_has_use_branching_in_lp() const;
  public:
  void clear_use_branching_in_lp();
  bool use_branching_in_lp() const;
  void set_use_branching_in_lp(bool value);
  private:
  bool _internal_use_branching_in_lp() const;
  void _internal_set_use_branching_in_lp(bool value);
  public:

  // optional bool use_combined_no_overlap = 133 [default = false];
  bool has_use_combined_no_overlap() const;
  private:
  bool _internal_has_use_combined_no_overlap() const;
  public:
  void clear_use_combined_no_overlap();
  bool use_combined_no_overlap() const;
  void set_use_combined_no_overlap(bool value);
  private:
  bool _internal_use_combined_no_overlap() const;
  void _internal_set_use_combined_no_overlap(bool value);
  public:

  // optional int64 probing_period_at_root = 142 [default = 0];
  bool has_probing_period_at_root() const;
  private:
  bool _internal_has_probing_period_at_root() const;
  public:
  void clear_probing_period_at_root();
  ::PROTOBUF_NAMESPACE_ID::int64 probing_period_at_root() const;
  void set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_probing_period_at_root() const;
  void _internal_set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
  bool has_cp_model_max_num_presolve_operations() const;
  private:
  bool _internal_has_cp_model_max_num_presolve_operations() const;
  public:
  void clear_cp_model_max_num_presolve_operations();
  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_max_num_presolve_operations() const;
  void set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cp_model_max_num_presolve_operations() const;
  void _internal_set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double absolute_gap_limit = 159 [default = 0];
  bool has_absolute_gap_limit() const;
  private:
  bool _internal_has_absolute_gap_limit() const;
  public:
  void clear_absolute_gap_limit();
  double absolute_gap_limit() const;
  void set_absolute_gap_limit(double value);
  private:
  double _internal_absolute_gap_limit() const;
  void _internal_set_absolute_gap_limit(double value);
  public:

  // optional double relative_gap_limit = 160 [default = 0];
  bool has_relative_gap_limit() const;
  private:
  bool _internal_has_relative_gap_limit() const;
  public:
  void clear_relative_gap_limit();
  double relative_gap_limit() const;
  void set_relative_gap_limit(double value);
  private:
  double _internal_relative_gap_limit() const;
  void _internal_set_relative_gap_limit(double value);
  public:

  // optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  bool has_fp_rounding() const;
  private:
  bool _internal_has_fp_rounding() const;
  public:
  void clear_fp_rounding();
  ::operations_research::sat::SatParameters_FPRoundingMethod fp_rounding() const;
  void set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value);
  private:
  ::operations_research::sat::SatParameters_FPRoundingMethod _internal_fp_rounding() const;
  void _internal_set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value);
  public:

  // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  bool has_initial_polarity() const;
  private:
  bool _internal_has_initial_polarity() const;
  public:
  void clear_initial_polarity();
  ::operations_research::sat::SatParameters_Polarity initial_polarity() const;
  void set_initial_polarity(::operations_research::sat::SatParameters_Polarity value);
  private:
  ::operations_research::sat::SatParameters_Polarity _internal_initial_polarity() const;
  void _internal_set_initial_polarity(::operations_research::sat::SatParameters_Polarity value);
  public:

  // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  bool has_minimization_algorithm() const;
  private:
  bool _internal_has_minimization_algorithm() const;
  public:
  void clear_minimization_algorithm();
  ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm minimization_algorithm() const;
  void set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value);
  private:
  ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm _internal_minimization_algorithm() const;
  void _internal_set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value);
  public:

  // optional int32 clause_cleanup_period = 11 [default = 10000];
  bool has_clause_cleanup_period() const;
  private:
  bool _internal_has_clause_cleanup_period() const;
  public:
  void clear_clause_cleanup_period();
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period() const;
  void set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_period() const;
  void _internal_set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 clause_cleanup_target = 13 [default = 10000];
  bool has_clause_cleanup_target() const;
  private:
  bool _internal_has_clause_cleanup_target() const;
  public:
  void clear_clause_cleanup_target();
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target() const;
  void set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_target() const;
  void _internal_set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double variable_activity_decay = 15 [default = 0.8];
  bool has_variable_activity_decay() const;
  private:
  bool _internal_has_variable_activity_decay() const;
  public:
  void clear_variable_activity_decay();
  double variable_activity_decay() const;
  void set_variable_activity_decay(double value);
  private:
  double _internal_variable_activity_decay() const;
  void _internal_set_variable_activity_decay(double value);
  public:

  // optional double max_variable_activity_value = 16 [default = 1e+100];
  bool has_max_variable_activity_value() const;
  private:
  bool _internal_has_max_variable_activity_value() const;
  public:
  void clear_max_variable_activity_value();
  double max_variable_activity_value() const;
  void set_max_variable_activity_value(double value);
  private:
  double _internal_max_variable_activity_value() const;
  void _internal_set_max_variable_activity_value(double value);
  public:

  // optional double clause_activity_decay = 17 [default = 0.999];
  bool has_clause_activity_decay() const;
  private:
  bool _internal_has_clause_activity_decay() const;
  public:
  void clear_clause_activity_decay();
  double clause_activity_decay() const;
  void set_clause_activity_decay(double value);
  private:
  double _internal_clause_activity_decay() const;
  void _internal_set_clause_activity_decay(double value);
  public:

  // optional double max_clause_activity_value = 18 [default = 1e+20];
  bool has_max_clause_activity_value() const;
  private:
  bool _internal_has_max_clause_activity_value() const;
  public:
  void clear_max_clause_activity_value();
  double max_clause_activity_value() const;
  void set_max_clause_activity_value(double value);
  private:
  double _internal_max_clause_activity_value() const;
  void _internal_set_max_clause_activity_value(double value);
  public:

  // optional double glucose_max_decay = 22 [default = 0.95];
  bool has_glucose_max_decay() const;
  private:
  bool _internal_has_glucose_max_decay() const;
  public:
  void clear_glucose_max_decay();
  double glucose_max_decay() const;
  void set_glucose_max_decay(double value);
  private:
  double _internal_glucose_max_decay() const;
  void _internal_set_glucose_max_decay(double value);
  public:

  // optional double glucose_decay_increment = 23 [default = 0.01];
  bool has_glucose_decay_increment() const;
  private:
  bool _internal_has_glucose_decay_increment() const;
  public:
  void clear_glucose_decay_increment();
  double glucose_decay_increment() const;
  void set_glucose_decay_increment(double value);
  private:
  double _internal_glucose_decay_increment() const;
  void _internal_set_glucose_decay_increment(double value);
  public:

  // optional int32 glucose_decay_increment_period = 24 [default = 5000];
  bool has_glucose_decay_increment_period() const;
  private:
  bool _internal_has_glucose_decay_increment_period() const;
  public:
  void clear_glucose_decay_increment_period();
  ::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period() const;
  void set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_glucose_decay_increment_period() const;
  void _internal_set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 restart_period = 30 [default = 50];
  bool has_restart_period() const;
  private:
  bool _internal_has_restart_period() const;
  public:
  void clear_restart_period();
  ::PROTOBUF_NAMESPACE_ID::int32 restart_period() const;
  void set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_restart_period() const;
  void _internal_set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 random_seed = 31 [default = 1];
  bool has_random_seed() const;
  private:
  bool _internal_has_random_seed() const;
  public:
  void clear_random_seed();
  ::PROTOBUF_NAMESPACE_ID::int32 random_seed() const;
  void set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_random_seed() const;
  void _internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  bool has_binary_minimization_algorithm() const;
  private:
  bool _internal_has_binary_minimization_algorithm() const;
  public:
  void clear_binary_minimization_algorithm();
  ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm binary_minimization_algorithm() const;
  void set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value);
  private:
  ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm _internal_binary_minimization_algorithm() const;
  void _internal_set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value);
  public:

  // optional double max_time_in_seconds = 36 [default = inf];
  bool has_max_time_in_seconds() const;
  private:
  bool _internal_has_max_time_in_seconds() const;
  public:
  void clear_max_time_in_seconds();
  double max_time_in_seconds() const;
  void set_max_time_in_seconds(double value);
  private:
  double _internal_max_time_in_seconds() const;
  void _internal_set_max_time_in_seconds(double value);
  public:

  // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  bool has_max_number_of_conflicts() const;
  private:
  bool _internal_has_max_number_of_conflicts() const;
  public:
  void clear_max_number_of_conflicts();
  ::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts() const;
  void set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_number_of_conflicts() const;
  void _internal_set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional int64 max_memory_in_mb = 40 [default = 10000];
  bool has_max_memory_in_mb() const;
  private:
  bool _internal_has_max_memory_in_mb() const;
  public:
  void clear_max_memory_in_mb();
  ::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb() const;
  void set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_memory_in_mb() const;
  void _internal_set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional bool use_phase_saving = 44 [default = true];
  bool has_use_phase_saving() const;
  private:
  bool _internal_has_use_phase_saving() const;
  public:
  void clear_use_phase_saving();
  bool use_phase_saving() const;
  void set_use_phase_saving(bool value);
  private:
  bool _internal_use_phase_saving() const;
  void _internal_set_use_phase_saving(bool value);
  public:

  // optional bool subsumption_during_conflict_analysis = 56 [default = true];
  bool has_subsumption_during_conflict_analysis() const;
  private:
  bool _internal_has_subsumption_during_conflict_analysis() const;
  public:
  void clear_subsumption_during_conflict_analysis();
  bool subsumption_during_conflict_analysis() const;
  void set_subsumption_during_conflict_analysis(bool value);
  private:
  bool _internal_subsumption_during_conflict_analysis() const;
  void _internal_set_subsumption_during_conflict_analysis(bool value);
  public:

  // optional bool treat_binary_clauses_separately = 33 [default = true];
  bool has_treat_binary_clauses_separately() const;
  private:
  bool _internal_has_treat_binary_clauses_separately() const;
  public:
  void clear_treat_binary_clauses_separately();
  bool treat_binary_clauses_separately() const;
  void set_treat_binary_clauses_separately(bool value);
  private:
  bool _internal_treat_binary_clauses_separately() const;
  void _internal_set_treat_binary_clauses_separately(bool value);
  public:

  // optional bool count_assumption_levels_in_lbd = 49 [default = true];
  bool has_count_assumption_levels_in_lbd() const;
  private:
  bool _internal_has_count_assumption_levels_in_lbd() const;
  public:
  void clear_count_assumption_levels_in_lbd();
  bool count_assumption_levels_in_lbd() const;
  void set_count_assumption_levels_in_lbd(bool value);
  private:
  bool _internal_count_assumption_levels_in_lbd() const;
  void _internal_set_count_assumption_levels_in_lbd(bool value);
  public:

  // optional int32 pb_cleanup_increment = 46 [default = 200];
  bool has_pb_cleanup_increment() const;
  private:
  bool _internal_has_pb_cleanup_increment() const;
  public:
  void clear_pb_cleanup_increment();
  ::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment() const;
  void set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_pb_cleanup_increment() const;
  void _internal_set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double pb_cleanup_ratio = 47 [default = 0.5];
  bool has_pb_cleanup_ratio() const;
  private:
  bool _internal_has_pb_cleanup_ratio() const;
  public:
  void clear_pb_cleanup_ratio();
  double pb_cleanup_ratio() const;
  void set_pb_cleanup_ratio(double value);
  private:
  double _internal_pb_cleanup_ratio() const;
  void _internal_set_pb_cleanup_ratio(double value);
  public:

  // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  bool has_max_sat_stratification() const;
  private:
  bool _internal_has_max_sat_stratification() const;
  public:
  void clear_max_sat_stratification();
  ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm max_sat_stratification() const;
  void set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value);
  private:
  ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm _internal_max_sat_stratification() const;
  void _internal_set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value);
  public:

  // optional int32 presolve_bve_threshold = 54 [default = 500];
  bool has_presolve_bve_threshold() const;
  private:
  bool _internal_has_presolve_bve_threshold() const;
  public:
  void clear_presolve_bve_threshold();
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold() const;
  void set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bve_threshold() const;
  void _internal_set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  bool has_presolve_probing_deterministic_time_limit() const;
  private:
  bool _internal_has_presolve_probing_deterministic_time_limit() const;
  public:
  void clear_presolve_probing_deterministic_time_limit();
  double presolve_probing_deterministic_time_limit() const;
  void set_presolve_probing_deterministic_time_limit(double value);
  private:
  double _internal_presolve_probing_deterministic_time_limit() const;
  void _internal_set_presolve_probing_deterministic_time_limit(double value);
  public:

  // optional int32 presolve_bve_clause_weight = 55 [default = 3];
  bool has_presolve_bve_clause_weight() const;
  private:
  bool _internal_has_presolve_bve_clause_weight() const;
  public:
  void clear_presolve_bve_clause_weight();
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight() const;
  void set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bve_clause_weight() const;
  void _internal_set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  bool has_clause_cleanup_lbd_bound() const;
  private:
  bool _internal_has_clause_cleanup_lbd_bound() const;
  public:
  void clear_clause_cleanup_lbd_bound();
  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound() const;
  void set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_lbd_bound() const;
  void _internal_set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double restart_dl_average_ratio = 63 [default = 1];
  bool has_restart_dl_average_ratio() const;
  private:
  bool _internal_has_restart_dl_average_ratio() const;
  public:
  void clear_restart_dl_average_ratio();
  double restart_dl_average_ratio() const;
  void set_restart_dl_average_ratio(double value);
  private:
  double _internal_restart_dl_average_ratio() const;
  void _internal_set_restart_dl_average_ratio(double value);
  public:

  // optional int32 restart_running_window_size = 62 [default = 50];
  bool has_restart_running_window_size() const;
  private:
  bool _internal_has_restart_running_window_size() const;
  public:
  void clear_restart_running_window_size();
  ::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size() const;
  void set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_restart_running_window_size() const;
  void _internal_set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 blocking_restart_window_size = 65 [default = 5000];
  bool has_blocking_restart_window_size() const;
  private:
  bool _internal_has_blocking_restart_window_size() const;
  public:
  void clear_blocking_restart_window_size();
  ::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size() const;
  void set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_blocking_restart_window_size() const;
  void _internal_set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double blocking_restart_multiplier = 66 [default = 1.4];
  bool has_blocking_restart_multiplier() const;
  private:
  bool _internal_has_blocking_restart_multiplier() const;
  public:
  void clear_blocking_restart_multiplier();
  double blocking_restart_multiplier() const;
  void set_blocking_restart_multiplier(double value);
  private:
  double _internal_blocking_restart_multiplier() const;
  void _internal_set_blocking_restart_multiplier(double value);
  public:

  // optional double max_deterministic_time = 67 [default = inf];
  bool has_max_deterministic_time() const;
  private:
  bool _internal_has_max_deterministic_time() const;
  public:
  void clear_max_deterministic_time();
  double max_deterministic_time() const;
  void set_max_deterministic_time(double value);
  private:
  double _internal_max_deterministic_time() const;
  void _internal_set_max_deterministic_time(double value);
  public:

  // optional double restart_lbd_average_ratio = 71 [default = 1];
  bool has_restart_lbd_average_ratio() const;
  private:
  bool _internal_has_restart_lbd_average_ratio() const;
  public:
  void clear_restart_lbd_average_ratio();
  double restart_lbd_average_ratio() const;
  void set_restart_lbd_average_ratio(double value);
  private:
  double _internal_restart_lbd_average_ratio() const;
  void _internal_set_restart_lbd_average_ratio(double value);
  public:

  // optional int32 presolve_bva_threshold = 73 [default = 1];
  bool has_presolve_bva_threshold() const;
  private:
  bool _internal_has_presolve_bva_threshold() const;
  public:
  void clear_presolve_bva_threshold();
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold() const;
  void set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bva_threshold() const;
  void _internal_set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional bool minimize_core = 50 [default = true];
  bool has_minimize_core() const;
  private:
  bool _internal_has_minimize_core() const;
  public:
  void clear_minimize_core();
  bool minimize_core() const;
  void set_minimize_core(bool value);
  private:
  bool _internal_minimize_core() const;
  void _internal_set_minimize_core(bool value);
  public:

  // optional bool find_multiple_cores = 84 [default = true];
  bool has_find_multiple_cores() const;
  private:
  bool _internal_has_find_multiple_cores() const;
  public:
  void clear_find_multiple_cores();
  bool find_multiple_cores() const;
  void set_find_multiple_cores(bool value);
  private:
  bool _internal_find_multiple_cores() const;
  void _internal_set_find_multiple_cores(bool value);
  public:

  // optional bool cover_optimization = 89 [default = true];
  bool has_cover_optimization() const;
  private:
  bool _internal_has_cover_optimization() const;
  public:
  void clear_cover_optimization();
  bool cover_optimization() const;
  void set_cover_optimization(bool value);
  private:
  bool _internal_cover_optimization() const;
  void _internal_set_cover_optimization(bool value);
  public:

  // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  bool has_use_precedences_in_disjunctive_constraint() const;
  private:
  bool _internal_has_use_precedences_in_disjunctive_constraint() const;
  public:
  void clear_use_precedences_in_disjunctive_constraint();
  bool use_precedences_in_disjunctive_constraint() const;
  void set_use_precedences_in_disjunctive_constraint(bool value);
  private:
  bool _internal_use_precedences_in_disjunctive_constraint() const;
  void _internal_set_use_precedences_in_disjunctive_constraint(bool value);
  public:

  // optional bool presolve_blocked_clause = 88 [default = true];
  bool has_presolve_blocked_clause() const;
  private:
  bool _internal_has_presolve_blocked_clause() const;
  public:
  void clear_presolve_blocked_clause();
  bool presolve_blocked_clause() const;
  void set_presolve_blocked_clause(bool value);
  private:
  bool _internal_presolve_blocked_clause() const;
  void _internal_set_presolve_blocked_clause(bool value);
  public:

  // optional bool presolve_use_bva = 72 [default = true];
  bool has_presolve_use_bva() const;
  private:
  bool _internal_has_presolve_use_bva() const;
  public:
  void clear_presolve_use_bva();
  bool presolve_use_bva() const;
  void set_presolve_use_bva(bool value);
  private:
  bool _internal_presolve_use_bva() const;
  void _internal_set_presolve_use_bva(bool value);
  public:

  // optional bool cp_model_presolve = 86 [default = true];
  bool has_cp_model_presolve() const;
  private:
  bool _internal_has_cp_model_presolve() const;
  public:
  void clear_cp_model_presolve();
  bool cp_model_presolve() const;
  void set_cp_model_presolve(bool value);
  private:
  bool _internal_cp_model_presolve() const;
  void _internal_set_cp_model_presolve(bool value);
  public:

  // optional bool cp_model_use_sat_presolve = 93 [default = true];
  bool has_cp_model_use_sat_presolve() const;
  private:
  bool _internal_has_cp_model_use_sat_presolve() const;
  public:
  void clear_cp_model_use_sat_presolve();
  bool cp_model_use_sat_presolve() const;
  void set_cp_model_use_sat_presolve(bool value);
  private:
  bool _internal_cp_model_use_sat_presolve() const;
  void _internal_set_cp_model_use_sat_presolve(bool value);
  public:

  // optional int32 linearization_level = 90 [default = 1];
  bool has_linearization_level() const;
  private:
  bool _internal_has_linearization_level() const;
  public:
  void clear_linearization_level();
  ::PROTOBUF_NAMESPACE_ID::int32 linearization_level() const;
  void set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_linearization_level() const;
  void _internal_set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 max_num_cuts = 91 [default = 10000];
  bool has_max_num_cuts() const;
  private:
  bool _internal_has_max_num_cuts() const;
  public:
  void clear_max_num_cuts();
  ::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts() const;
  void set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_num_cuts() const;
  void _internal_set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  bool has_minimize_with_propagation_restart_period() const;
  private:
  bool _internal_has_minimize_with_propagation_restart_period() const;
  public:
  void clear_minimize_with_propagation_restart_period();
  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period() const;
  void set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_minimize_with_propagation_restart_period() const;
  void _internal_set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  bool has_minimize_with_propagation_num_decisions() const;
  private:
  bool _internal_has_minimize_with_propagation_num_decisions() const;
  public:
  void clear_minimize_with_propagation_num_decisions();
  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions() const;
  void set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_minimize_with_propagation_num_decisions() const;
  void _internal_set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 binary_search_num_conflicts = 99 [default = -1];
  bool has_binary_search_num_conflicts() const;
  private:
  bool _internal_has_binary_search_num_conflicts() const;
  public:
  void clear_binary_search_num_conflicts();
  ::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts() const;
  void set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_binary_search_num_conflicts() const;
  void _internal_set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 num_search_workers = 100 [default = 1];
  bool has_num_search_workers() const;
  private:
  bool _internal_has_num_search_workers() const;
  public:
  void clear_num_search_workers();
  ::PROTOBUF_NAMESPACE_ID::int32 num_search_workers() const;
  void set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_search_workers() const;
  void _internal_set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 boolean_encoding_level = 107 [default = 1];
  bool has_boolean_encoding_level() const;
  private:
  bool _internal_has_boolean_encoding_level() const;
  public:
  void clear_boolean_encoding_level();
  ::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level() const;
  void set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_boolean_encoding_level() const;
  void _internal_set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional bool instantiate_all_variables = 106 [default = true];
  bool has_instantiate_all_variables() const;
  private:
  bool _internal_has_instantiate_all_variables() const;
  public:
  void clear_instantiate_all_variables();
  bool instantiate_all_variables() const;
  void set_instantiate_all_variables(bool value);
  private:
  bool _internal_instantiate_all_variables() const;
  void _internal_set_instantiate_all_variables(bool value);
  public:

  // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  bool has_auto_detect_greater_than_at_least_one_of() const;
  private:
  bool _internal_has_auto_detect_greater_than_at_least_one_of() const;
  public:
  void clear_auto_detect_greater_than_at_least_one_of();
  bool auto_detect_greater_than_at_least_one_of() const;
  void set_auto_detect_greater_than_at_least_one_of(bool value);
  private:
  bool _internal_auto_detect_greater_than_at_least_one_of() const;
  void _internal_set_auto_detect_greater_than_at_least_one_of(bool value);
  public:

  // optional bool share_objective_bounds = 113 [default = true];
  bool has_share_objective_bounds() const;
  private:
  bool _internal_has_share_objective_bounds() const;
  public:
  void clear_share_objective_bounds();
  bool share_objective_bounds() const;
  void set_share_objective_bounds(bool value);
  private:
  bool _internal_share_objective_bounds() const;
  void _internal_set_share_objective_bounds(bool value);
  public:

  // optional bool share_level_zero_bounds = 114 [default = true];
  bool has_share_level_zero_bounds() const;
  private:
  bool _internal_has_share_level_zero_bounds() const;
  public:
  void clear_share_level_zero_bounds();
  bool share_level_zero_bounds() const;
  void set_share_level_zero_bounds(bool value);
  private:
  bool _internal_share_level_zero_bounds() const;
  void _internal_set_share_level_zero_bounds(bool value);
  public:

  // optional int32 cp_model_probing_level = 110 [default = 2];
  bool has_cp_model_probing_level() const;
  private:
  bool _internal_has_cp_model_probing_level() const;
  public:
  void clear_cp_model_probing_level();
  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level() const;
  void set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cp_model_probing_level() const;
  void _internal_set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  bool has_min_orthogonality_for_lp_constraints() const;
  private:
  bool _internal_has_min_orthogonality_for_lp_constraints() const;
  public:
  void clear_min_orthogonality_for_lp_constraints();
  double min_orthogonality_for_lp_constraints() const;
  void set_min_orthogonality_for_lp_constraints(double value);
  private:
  double _internal_min_orthogonality_for_lp_constraints() const;
  void _internal_set_min_orthogonality_for_lp_constraints(double value);
  public:

  // optional bool add_lp_constraints_lazily = 112 [default = true];
  bool has_add_lp_constraints_lazily() const;
  private:
  bool _internal_has_add_lp_constraints_lazily() const;
  public:
  void clear_add_lp_constraints_lazily();
  bool add_lp_constraints_lazily() const;
  void set_add_lp_constraints_lazily(bool value);
  private:
  bool _internal_add_lp_constraints_lazily() const;
  void _internal_set_add_lp_constraints_lazily(bool value);
  public:

  // optional bool exploit_integer_lp_solution = 94 [default = true];
  bool has_exploit_integer_lp_solution() const;
  private:
  bool _internal_has_exploit_integer_lp_solution() const;
  public:
  void clear_exploit_integer_lp_solution();
  bool exploit_integer_lp_solution() const;
  void set_exploit_integer_lp_solution(bool value);
  private:
  bool _internal_exploit_integer_lp_solution() const;
  void _internal_set_exploit_integer_lp_solution(bool value);
  public:

  // optional bool exploit_all_lp_solution = 116 [default = true];
  bool has_exploit_all_lp_solution() const;
  private:
  bool _internal_has_exploit_all_lp_solution() const;
  public:
  void clear_exploit_all_lp_solution();
  bool exploit_all_lp_solution() const;
  void set_exploit_all_lp_solution(bool value);
  private:
  bool _internal_exploit_all_lp_solution() const;
  void _internal_set_exploit_all_lp_solution(bool value);
  public:

  // optional bool exploit_objective = 131 [default = true];
  bool has_exploit_objective() const;
  private:
  bool _internal_has_exploit_objective() const;
  public:
  void clear_exploit_objective();
  bool exploit_objective() const;
  void set_exploit_objective(bool value);
  private:
  bool _internal_exploit_objective() const;
  void _internal_set_exploit_objective(bool value);
  public:

  // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  bool has_use_disjunctive_constraint_in_cumulative_constraint() const;
  private:
  bool _internal_has_use_disjunctive_constraint_in_cumulative_constraint() const;
  public:
  void clear_use_disjunctive_constraint_in_cumulative_constraint();
  bool use_disjunctive_constraint_in_cumulative_constraint() const;
  void set_use_disjunctive_constraint_in_cumulative_constraint(bool value);
  private:
  bool _internal_use_disjunctive_constraint_in_cumulative_constraint() const;
  void _internal_set_use_disjunctive_constraint_in_cumulative_constraint(bool value);
  public:

  // optional bool add_cg_cuts = 117 [default = true];
  bool has_add_cg_cuts() const;
  private:
  bool _internal_has_add_cg_cuts() const;
  public:
  void clear_add_cg_cuts();
  bool add_cg_cuts() const;
  void set_add_cg_cuts(bool value);
  private:
  bool _internal_add_cg_cuts() const;
  void _internal_set_add_cg_cuts(bool value);
  public:

  // optional bool add_mir_cuts = 120 [default = true];
  bool has_add_mir_cuts() const;
  private:
  bool _internal_has_add_mir_cuts() const;
  public:
  void clear_add_mir_cuts();
  bool add_mir_cuts() const;
  void set_add_mir_cuts(bool value);
  private:
  bool _internal_add_mir_cuts() const;
  void _internal_set_add_mir_cuts(bool value);
  public:

  // optional bool add_lin_max_cuts = 152 [default = true];
  bool has_add_lin_max_cuts() const;
  private:
  bool _internal_has_add_lin_max_cuts() const;
  public:
  void clear_add_lin_max_cuts();
  bool add_lin_max_cuts() const;
  void set_add_lin_max_cuts(bool value);
  private:
  bool _internal_add_lin_max_cuts() const;
  void _internal_set_add_lin_max_cuts(bool value);
  public:

  // optional int32 max_integer_rounding_scaling = 119 [default = 600];
  bool has_max_integer_rounding_scaling() const;
  private:
  bool _internal_has_max_integer_rounding_scaling() const;
  public:
  void clear_max_integer_rounding_scaling();
  ::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling() const;
  void set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_integer_rounding_scaling() const;
  void _internal_set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional bool expand_element_constraints = 140 [default = true];
  bool has_expand_element_constraints() const;
  private:
  bool _internal_has_expand_element_constraints() const;
  public:
  void clear_expand_element_constraints();
  bool expand_element_constraints() const;
  void set_expand_element_constraints(bool value);
  private:
  bool _internal_expand_element_constraints() const;
  void _internal_set_expand_element_constraints(bool value);
  public:

  // optional bool expand_automaton_constraints = 143 [default = true];
  bool has_expand_automaton_constraints() const;
  private:
  bool _internal_has_expand_automaton_constraints() const;
  public:
  void clear_expand_automaton_constraints();
  bool expand_automaton_constraints() const;
  void set_expand_automaton_constraints(bool value);
  private:
  bool _internal_expand_automaton_constraints() const;
  void _internal_set_expand_automaton_constraints(bool value);
  public:

  // optional bool expand_table_constraints = 158 [default = true];
  bool has_expand_table_constraints() const;
  private:
  bool _internal_has_expand_table_constraints() const;
  public:
  void clear_expand_table_constraints();
  bool expand_table_constraints() const;
  void set_expand_table_constraints(bool value);
  private:
  bool _internal_expand_table_constraints() const;
  void _internal_set_expand_table_constraints(bool value);
  public:

  // optional bool use_optimization_hints = 35 [default = true];
  bool has_use_optimization_hints() const;
  private:
  bool _internal_has_use_optimization_hints() const;
  public:
  void clear_use_optimization_hints();
  bool use_optimization_hints() const;
  void set_use_optimization_hints(bool value);
  private:
  bool _internal_use_optimization_hints() const;
  void _internal_set_use_optimization_hints(bool value);
  public:

  // optional int32 max_consecutive_inactive_count = 121 [default = 100];
  bool has_max_consecutive_inactive_count() const;
  private:
  bool _internal_has_max_consecutive_inactive_count() const;
  public:
  void clear_max_consecutive_inactive_count();
  ::PROTOBUF_NAMESPACE_ID::int32 max_consecutive_inactive_count() const;
  void set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_consecutive_inactive_count() const;
  void _internal_set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 new_constraints_batch_size = 122 [default = 50];
  bool has_new_constraints_batch_size() const;
  private:
  bool _internal_has_new_constraints_batch_size() const;
  public:
  void clear_new_constraints_batch_size();
  ::PROTOBUF_NAMESPACE_ID::int32 new_constraints_batch_size() const;
  void set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_new_constraints_batch_size() const;
  void _internal_set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  bool has_pseudo_cost_reliability_threshold() const;
  private:
  bool _internal_has_pseudo_cost_reliability_threshold() const;
  public:
  void clear_pseudo_cost_reliability_threshold();
  ::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold() const;
  void set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_pseudo_cost_reliability_threshold() const;
  void _internal_set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // optional double mip_max_bound = 124 [default = 10000000];
  bool has_mip_max_bound() const;
  private:
  bool _internal_has_mip_max_bound() const;
  public:
  void clear_mip_max_bound();
  double mip_max_bound() const;
  void set_mip_max_bound(double value);
  private:
  double _internal_mip_max_bound() const;
  void _internal_set_mip_max_bound(double value);
  public:

  // optional double mip_var_scaling = 125 [default = 1];
  bool has_mip_var_scaling() const;
  private:
  bool _internal_has_mip_var_scaling() const;
  public:
  void clear_mip_var_scaling();
  double mip_var_scaling() const;
  void set_mip_var_scaling(double value);
  private:
  double _internal_mip_var_scaling() const;
  void _internal_set_mip_var_scaling(double value);
  public:

  // optional double mip_wanted_precision = 126 [default = 1e-06];
  bool has_mip_wanted_precision() const;
  private:
  bool _internal_has_mip_wanted_precision() const;
  public:
  void clear_mip_wanted_precision();
  double mip_wanted_precision() const;
  void set_mip_wanted_precision(double value);
  private:
  double _internal_mip_wanted_precision() const;
  void _internal_set_mip_wanted_precision(double value);
  public:

  // optional int32 mip_max_activity_exponent = 127 [default = 53];
  bool has_mip_max_activity_exponent() const;
  private:
  bool _internal_has_mip_max_activity_exponent() const;
  public:
  void clear_mip_max_activity_exponent();
  ::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent() const;
  void set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_mip_max_activity_exponent() const;
  void _internal_set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional bool use_rins_lns = 129 [default = true];
  bool has_use_rins_lns() const;
  private:
  bool _internal_has_use_rins_lns() const;
  public:
  void clear_use_rins_lns();
  bool use_rins_lns() const;
  void set_use_rins_lns(bool value);
  private:
  bool _internal_use_rins_lns() const;
  void _internal_set_use_rins_lns(bool value);
  public:

  // optional bool use_feasibility_pump = 164 [default = true];
  bool has_use_feasibility_pump() const;
  private:
  bool _internal_has_use_feasibility_pump() const;
  public:
  void clear_use_feasibility_pump();
  bool use_feasibility_pump() const;
  void set_use_feasibility_pump(bool value);
  private:
  bool _internal_use_feasibility_pump() const;
  void _internal_set_use_feasibility_pump(bool value);
  public:

  // optional bool use_optional_variables = 108 [default = true];
  bool has_use_optional_variables() const;
  private:
  bool _internal_has_use_optional_variables() const;
  public:
  void clear_use_optional_variables();
  bool use_optional_variables() const;
  void set_use_optional_variables(bool value);
  private:
  bool _internal_use_optional_variables() const;
  void _internal_set_use_optional_variables(bool value);
  public:

  // optional bool use_exact_lp_reason = 109 [default = true];
  bool has_use_exact_lp_reason() const;
  private:
  bool _internal_has_use_exact_lp_reason() const;
  public:
  void clear_use_exact_lp_reason();
  bool use_exact_lp_reason() const;
  void set_use_exact_lp_reason(bool value);
  private:
  bool _internal_use_exact_lp_reason() const;
  void _internal_set_use_exact_lp_reason(bool value);
  public:

  // optional double mip_check_precision = 128 [default = 0.0001];
  bool has_mip_check_precision() const;
  private:
  bool _internal_has_mip_check_precision() const;
  public:
  void clear_mip_check_precision();
  double mip_check_precision() const;
  void set_mip_check_precision(double value);
  private:
  double _internal_mip_check_precision() const;
  void _internal_set_mip_check_precision(double value);
  public:

  // optional int32 interleave_batch_size = 134 [default = 1];
  bool has_interleave_batch_size() const;
  private:
  bool _internal_has_interleave_batch_size() const;
  public:
  void clear_interleave_batch_size();
  ::PROTOBUF_NAMESPACE_ID::int32 interleave_batch_size() const;
  void set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_interleave_batch_size() const;
  void _internal_set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 max_presolve_iterations = 138 [default = 3];
  bool has_max_presolve_iterations() const;
  private:
  bool _internal_has_max_presolve_iterations() const;
  public:
  void clear_max_presolve_iterations();
  ::PROTOBUF_NAMESPACE_ID::int32 max_presolve_iterations() const;
  void set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_presolve_iterations() const;
  void _internal_set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  bool has_merge_no_overlap_work_limit() const;
  private:
  bool _internal_has_merge_no_overlap_work_limit() const;
  public:
  void clear_merge_no_overlap_work_limit();
  double merge_no_overlap_work_limit() const;
  void set_merge_no_overlap_work_limit(double value);
  private:
  double _internal_merge_no_overlap_work_limit() const;
  void _internal_set_merge_no_overlap_work_limit(double value);
  public:

  // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  bool has_merge_at_most_one_work_limit() const;
  private:
  bool _internal_has_merge_at_most_one_work_limit() const;
  public:
  void clear_merge_at_most_one_work_limit();
  double merge_at_most_one_work_limit() const;
  void set_merge_at_most_one_work_limit(double value);
  private:
  double _internal_merge_at_most_one_work_limit() const;
  void _internal_set_merge_at_most_one_work_limit(double value);
  public:

  // optional int32 presolve_substitution_level = 147 [default = 1];
  bool has_presolve_substitution_level() const;
  private:
  bool _internal_has_presolve_substitution_level() const;
  public:
  void clear_presolve_substitution_level();
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_substitution_level() const;
  void set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_substitution_level() const;
  void _internal_set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 max_all_diff_cut_size = 148 [default = 7];
  bool has_max_all_diff_cut_size() const;
  private:
  bool _internal_has_max_all_diff_cut_size() const;
  public:
  void clear_max_all_diff_cut_size();
  ::PROTOBUF_NAMESPACE_ID::int32 max_all_diff_cut_size() const;
  void set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_all_diff_cut_size() const;
  void _internal_set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional bool catch_sigint_signal = 135 [default = true];
  bool has_catch_sigint_signal() const;
  private:
  bool _internal_has_catch_sigint_signal() const;
  public:
  void clear_catch_sigint_signal();
  bool catch_sigint_signal() const;
  void set_catch_sigint_signal(bool value);
  private:
  bool _internal_catch_sigint_signal() const;
  void _internal_set_catch_sigint_signal(bool value);
  public:

  // optional bool use_implied_bounds = 144 [default = true];
  bool has_use_implied_bounds() const;
  private:
  bool _internal_has_use_implied_bounds() const;
  public:
  void clear_use_implied_bounds();
  bool use_implied_bounds() const;
  void set_use_implied_bounds(bool value);
  private:
  bool _internal_use_implied_bounds() const;
  void _internal_set_use_implied_bounds(bool value);
  public:

  // optional bool mip_automatically_scale_variables = 166 [default = true];
  bool has_mip_automatically_scale_variables() const;
  private:
  bool _internal_has_mip_automatically_scale_variables() const;
  public:
  void clear_mip_automatically_scale_variables();
  bool mip_automatically_scale_variables() const;
  void set_mip_automatically_scale_variables(bool value);
  private:
  bool _internal_mip_automatically_scale_variables() const;
  void _internal_set_mip_automatically_scale_variables(bool value);
  public:

  // optional int32 hint_conflict_limit = 153 [default = 10];
  bool has_hint_conflict_limit() const;
  private:
  bool _internal_has_hint_conflict_limit() const;
  public:
  void clear_hint_conflict_limit();
  ::PROTOBUF_NAMESPACE_ID::int32 hint_conflict_limit() const;
  void set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_hint_conflict_limit() const;
  void _internal_set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double cut_max_active_count_value = 155 [default = 10000000000];
  bool has_cut_max_active_count_value() const;
  private:
  bool _internal_has_cut_max_active_count_value() const;
  public:
  void clear_cut_max_active_count_value();
  double cut_max_active_count_value() const;
  void set_cut_max_active_count_value(double value);
  private:
  double _internal_cut_max_active_count_value() const;
  void _internal_set_cut_max_active_count_value(double value);
  public:

  // optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  bool has_max_cut_rounds_at_level_zero() const;
  private:
  bool _internal_has_max_cut_rounds_at_level_zero() const;
  public:
  void clear_max_cut_rounds_at_level_zero();
  ::PROTOBUF_NAMESPACE_ID::int32 max_cut_rounds_at_level_zero() const;
  void set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_cut_rounds_at_level_zero() const;
  void _internal_set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional int32 cut_cleanup_target = 157 [default = 1000];
  bool has_cut_cleanup_target() const;
  private:
  bool _internal_has_cut_cleanup_target() const;
  public:
  void clear_cut_cleanup_target();
  ::PROTOBUF_NAMESPACE_ID::int32 cut_cleanup_target() const;
  void set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cut_cleanup_target() const;
  void _internal_set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // optional double cut_active_count_decay = 156 [default = 0.8];
  bool has_cut_active_count_decay() const;
  private:
  bool _internal_has_cut_active_count_decay() const;
  public:
  void clear_cut_active_count_decay();
  double cut_active_count_decay() const;
  void set_cut_active_count_decay(double value);
  private:
  double _internal_cut_active_count_decay() const;
  void _internal_set_cut_active_count_decay(double value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<5> _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_;
  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_;
  ::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes_;
  double strategy_change_increase_ratio_;
  double initial_variables_activity_;
  bool max_sat_reverse_assumption_order_;
  bool use_overload_checker_in_cumulative_constraint_;
  bool use_timetable_edge_finding_in_cumulative_constraint_;
  bool only_add_cuts_at_level_zero_;
  int search_branching_;
  bool optimize_with_max_hs_;
  bool enumerate_all_solutions_;
  bool fill_tightened_domains_in_response_;
  bool stop_after_first_solution_;
  bool use_pb_resolution_;
  bool minimize_reduction_during_pb_resolution_;
  bool cp_model_postsolve_with_full_solver_;
  bool use_sat_inprocessing_;
  ::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance_;
  bool add_knapsack_cuts_;
  bool exploit_best_solution_;
  bool exploit_relaxation_solution_;
  bool optimize_with_core_;
  bool lns_focus_on_decision_variables_;
  bool use_relaxation_lns_;
  bool diversify_lns_params_;
  bool randomize_search_;
  bool stop_after_presolve_;
  bool interleave_search_;
  bool reduce_memory_usage_in_interleave_mode_;
  bool use_lns_only_;
  bool use_branching_in_lp_;
  bool use_combined_no_overlap_;
  ::PROTOBUF_NAMESPACE_ID::int64 probing_period_at_root_;
  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_max_num_presolve_operations_;
  double absolute_gap_limit_;
  double relative_gap_limit_;
  int fp_rounding_;
  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_;
  double restart_dl_average_ratio_;
  ::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size_;
  double blocking_restart_multiplier_;
  double max_deterministic_time_;
  double restart_lbd_average_ratio_;
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold_;
  bool minimize_core_;
  bool find_multiple_cores_;
  bool cover_optimization_;
  bool use_precedences_in_disjunctive_constraint_;
  bool presolve_blocked_clause_;
  bool presolve_use_bva_;
  bool cp_model_presolve_;
  bool cp_model_use_sat_presolve_;
  ::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_;
  ::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_;
  double min_orthogonality_for_lp_constraints_;
  bool add_lp_constraints_lazily_;
  bool exploit_integer_lp_solution_;
  bool exploit_all_lp_solution_;
  bool exploit_objective_;
  bool use_disjunctive_constraint_in_cumulative_constraint_;
  bool add_cg_cuts_;
  bool add_mir_cuts_;
  bool add_lin_max_cuts_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling_;
  bool expand_element_constraints_;
  bool expand_automaton_constraints_;
  bool expand_table_constraints_;
  bool use_optimization_hints_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_consecutive_inactive_count_;
  ::PROTOBUF_NAMESPACE_ID::int32 new_constraints_batch_size_;
  ::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold_;
  double mip_max_bound_;
  double mip_var_scaling_;
  double mip_wanted_precision_;
  ::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent_;
  bool use_rins_lns_;
  bool use_feasibility_pump_;
  bool use_optional_variables_;
  bool use_exact_lp_reason_;
  double mip_check_precision_;
  ::PROTOBUF_NAMESPACE_ID::int32 interleave_batch_size_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_presolve_iterations_;
  double merge_no_overlap_work_limit_;
  double merge_at_most_one_work_limit_;
  ::PROTOBUF_NAMESPACE_ID::int32 presolve_substitution_level_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_all_diff_cut_size_;
  bool catch_sigint_signal_;
  bool use_implied_bounds_;
  bool mip_automatically_scale_variables_;
  ::PROTOBUF_NAMESPACE_ID::int32 hint_conflict_limit_;
  double cut_max_active_count_value_;
  ::PROTOBUF_NAMESPACE_ID::int32 max_cut_rounds_at_level_zero_;
  ::PROTOBUF_NAMESPACE_ID::int32 cut_cleanup_target_;
  double cut_active_count_decay_;
  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::_internal_has_preferred_variable_order() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SatParameters::has_preferred_variable_order() const {
  return _internal_has_preferred_variable_order();
}
inline void SatParameters::clear_preferred_variable_order() {
  preferred_variable_order_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::operations_research::sat::SatParameters_VariableOrder SatParameters::_internal_preferred_variable_order() const {
  return static_cast< ::operations_research::sat::SatParameters_VariableOrder >(preferred_variable_order_);
}
inline ::operations_research::sat::SatParameters_VariableOrder SatParameters::preferred_variable_order() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.preferred_variable_order)
  return _internal_preferred_variable_order();
}
inline void SatParameters::_internal_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;
}
inline void SatParameters::set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value) {
  _internal_set_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::_internal_has_initial_polarity() const {
  bool value = (_has_bits_[1] & 0x00008000u) != 0;
  return value;
}
inline bool SatParameters::has_initial_polarity() const {
  return _internal_has_initial_polarity();
}
inline void SatParameters::clear_initial_polarity() {
  initial_polarity_ = 1;
  _has_bits_[1] &= ~0x00008000u;
}
inline ::operations_research::sat::SatParameters_Polarity SatParameters::_internal_initial_polarity() const {
  return static_cast< ::operations_research::sat::SatParameters_Polarity >(initial_polarity_);
}
inline ::operations_research::sat::SatParameters_Polarity SatParameters::initial_polarity() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.initial_polarity)
  return _internal_initial_polarity();
}
inline void SatParameters::_internal_set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
  assert(::operations_research::sat::SatParameters_Polarity_IsValid(value));
  _has_bits_[1] |= 0x00008000u;
  initial_polarity_ = value;
}
inline void SatParameters::set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
  _internal_set_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::_internal_has_use_phase_saving() const {
  bool value = (_has_bits_[2] & 0x00000001u) != 0;
  return value;
}
inline bool SatParameters::has_use_phase_saving() const {
  return _internal_has_use_phase_saving();
}
inline void SatParameters::clear_use_phase_saving() {
  use_phase_saving_ = true;
  _has_bits_[2] &= ~0x00000001u;
}
inline bool SatParameters::_internal_use_phase_saving() const {
  return use_phase_saving_;
}
inline bool SatParameters::use_phase_saving() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_phase_saving)
  return _internal_use_phase_saving();
}
inline void SatParameters::_internal_set_use_phase_saving(bool value) {
  _has_bits_[2] |= 0x00000001u;
  use_phase_saving_ = value;
}
inline void SatParameters::set_use_phase_saving(bool value) {
  _internal_set_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::_internal_has_random_polarity_ratio() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool SatParameters::has_random_polarity_ratio() const {
  return _internal_has_random_polarity_ratio();
}
inline void SatParameters::clear_random_polarity_ratio() {
  random_polarity_ratio_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline double SatParameters::_internal_random_polarity_ratio() const {
  return random_polarity_ratio_;
}
inline double SatParameters::random_polarity_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_polarity_ratio)
  return _internal_random_polarity_ratio();
}
inline void SatParameters::_internal_set_random_polarity_ratio(double value) {
  _has_bits_[0] |= 0x00000010u;
  random_polarity_ratio_ = value;
}
inline void SatParameters::set_random_polarity_ratio(double value) {
  _internal_set_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::_internal_has_random_branches_ratio() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool SatParameters::has_random_branches_ratio() const {
  return _internal_has_random_branches_ratio();
}
inline void SatParameters::clear_random_branches_ratio() {
  random_branches_ratio_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline double SatParameters::_internal_random_branches_ratio() const {
  return random_branches_ratio_;
}
inline double SatParameters::random_branches_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_branches_ratio)
  return _internal_random_branches_ratio();
}
inline void SatParameters::_internal_set_random_branches_ratio(double value) {
  _has_bits_[0] |= 0x00000008u;
  random_branches_ratio_ = value;
}
inline void SatParameters::set_random_branches_ratio(double value) {
  _internal_set_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::_internal_has_use_erwa_heuristic() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool SatParameters::has_use_erwa_heuristic() const {
  return _internal_has_use_erwa_heuristic();
}
inline void SatParameters::clear_use_erwa_heuristic() {
  use_erwa_heuristic_ = false;
  _has_bits_[0] &= ~0x00000080u;
}
inline bool SatParameters::_internal_use_erwa_heuristic() const {
  return use_erwa_heuristic_;
}
inline bool SatParameters::use_erwa_heuristic() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_erwa_heuristic)
  return _internal_use_erwa_heuristic();
}
inline void SatParameters::_internal_set_use_erwa_heuristic(bool value) {
  _has_bits_[0] |= 0x00000080u;
  use_erwa_heuristic_ = value;
}
inline void SatParameters::set_use_erwa_heuristic(bool value) {
  _internal_set_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::_internal_has_initial_variables_activity() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool SatParameters::has_initial_variables_activity() const {
  return _internal_has_initial_variables_activity();
}
inline void SatParameters::clear_initial_variables_activity() {
  initial_variables_activity_ = 0;
  _has_bits_[0] &= ~0x00002000u;
}
inline double SatParameters::_internal_initial_variables_activity() const {
  return initial_variables_activity_;
}
inline double SatParameters::initial_variables_activity() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.initial_variables_activity)
  return _internal_initial_variables_activity();
}
inline void SatParameters::_internal_set_initial_variables_activity(double value) {
  _has_bits_[0] |= 0x00002000u;
  initial_variables_activity_ = value;
}
inline void SatParameters::set_initial_variables_activity(double value) {
  _internal_set_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::_internal_has_also_bump_variables_in_conflict_reasons() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool SatParameters::has_also_bump_variables_in_conflict_reasons() const {
  return _internal_has_also_bump_variables_in_conflict_reasons();
}
inline void SatParameters::clear_also_bump_variables_in_conflict_reasons() {
  also_bump_variables_in_conflict_reasons_ = false;
  _has_bits_[0] &= ~0x00000100u;
}
inline bool SatParameters::_internal_also_bump_variables_in_conflict_reasons() const {
  return also_bump_variables_in_conflict_reasons_;
}
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 _internal_also_bump_variables_in_conflict_reasons();
}
inline void SatParameters::_internal_set_also_bump_variables_in_conflict_reasons(bool value) {
  _has_bits_[0] |= 0x00000100u;
  also_bump_variables_in_conflict_reasons_ = value;
}
inline void SatParameters::set_also_bump_variables_in_conflict_reasons(bool value) {
  _internal_set_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::_internal_has_minimization_algorithm() const {
  bool value = (_has_bits_[1] & 0x00010000u) != 0;
  return value;
}
inline bool SatParameters::has_minimization_algorithm() const {
  return _internal_has_minimization_algorithm();
}
inline void SatParameters::clear_minimization_algorithm() {
  minimization_algorithm_ = 2;
  _has_bits_[1] &= ~0x00010000u;
}
inline ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm SatParameters::_internal_minimization_algorithm() const {
  return static_cast< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm >(minimization_algorithm_);
}
inline ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm SatParameters::minimization_algorithm() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimization_algorithm)
  return _internal_minimization_algorithm();
}
inline void SatParameters::_internal_set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
  assert(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_IsValid(value));
  _has_bits_[1] |= 0x00010000u;
  minimization_algorithm_ = value;
}
inline void SatParameters::set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
  _internal_set_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::_internal_has_binary_minimization_algorithm() const {
  bool value = (_has_bits_[1] & 0x10000000u) != 0;
  return value;
}
inline bool SatParameters::has_binary_minimization_algorithm() const {
  return _internal_has_binary_minimization_algorithm();
}
inline void SatParameters::clear_binary_minimization_algorithm() {
  binary_minimization_algorithm_ = 1;
  _has_bits_[1] &= ~0x10000000u;
}
inline ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm SatParameters::_internal_binary_minimization_algorithm() const {
  return static_cast< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm >(binary_minimization_algorithm_);
}
inline ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm SatParameters::binary_minimization_algorithm() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.binary_minimization_algorithm)
  return _internal_binary_minimization_algorithm();
}
inline void SatParameters::_internal_set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
  assert(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_IsValid(value));
  _has_bits_[1] |= 0x10000000u;
  binary_minimization_algorithm_ = value;
}
inline void SatParameters::set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
  _internal_set_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::_internal_has_subsumption_during_conflict_analysis() const {
  bool value = (_has_bits_[2] & 0x00000002u) != 0;
  return value;
}
inline bool SatParameters::has_subsumption_during_conflict_analysis() const {
  return _internal_has_subsumption_during_conflict_analysis();
}
inline void SatParameters::clear_subsumption_during_conflict_analysis() {
  subsumption_during_conflict_analysis_ = true;
  _has_bits_[2] &= ~0x00000002u;
}
inline bool SatParameters::_internal_subsumption_during_conflict_analysis() const {
  return subsumption_during_conflict_analysis_;
}
inline bool SatParameters::subsumption_during_conflict_analysis() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.subsumption_during_conflict_analysis)
  return _internal_subsumption_during_conflict_analysis();
}
inline void SatParameters::_internal_set_subsumption_during_conflict_analysis(bool value) {
  _has_bits_[2] |= 0x00000002u;
  subsumption_during_conflict_analysis_ = value;
}
inline void SatParameters::set_subsumption_during_conflict_analysis(bool value) {
  _internal_set_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::_internal_has_clause_cleanup_period() const {
  bool value = (_has_bits_[1] & 0x00020000u) != 0;
  return value;
}
inline bool SatParameters::has_clause_cleanup_period() const {
  return _internal_has_clause_cleanup_period();
}
inline void SatParameters::clear_clause_cleanup_period() {
  clause_cleanup_period_ = 10000;
  _has_bits_[1] &= ~0x00020000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_period() const {
  return clause_cleanup_period_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_period() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_period)
  return _internal_clause_cleanup_period();
}
inline void SatParameters::_internal_set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00020000u;
  clause_cleanup_period_ = value;
}
inline void SatParameters::set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_clause_cleanup_target() const {
  bool value = (_has_bits_[1] & 0x00040000u) != 0;
  return value;
}
inline bool SatParameters::has_clause_cleanup_target() const {
  return _internal_has_clause_cleanup_target();
}
inline void SatParameters::clear_clause_cleanup_target() {
  clause_cleanup_target_ = 10000;
  _has_bits_[1] &= ~0x00040000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_target() const {
  return clause_cleanup_target_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_target() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_target)
  return _internal_clause_cleanup_target();
}
inline void SatParameters::_internal_set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00040000u;
  clause_cleanup_target_ = value;
}
inline void SatParameters::set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_clause_cleanup_protection() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool SatParameters::has_clause_cleanup_protection() const {
  return _internal_has_clause_cleanup_protection();
}
inline void SatParameters::clear_clause_cleanup_protection() {
  clause_cleanup_protection_ = 0;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::operations_research::sat::SatParameters_ClauseProtection SatParameters::_internal_clause_cleanup_protection() const {
  return static_cast< ::operations_research::sat::SatParameters_ClauseProtection >(clause_cleanup_protection_);
}
inline ::operations_research::sat::SatParameters_ClauseProtection SatParameters::clause_cleanup_protection() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_protection)
  return _internal_clause_cleanup_protection();
}
inline void SatParameters::_internal_set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value) {
  assert(::operations_research::sat::SatParameters_ClauseProtection_IsValid(value));
  _has_bits_[0] |= 0x00000020u;
  clause_cleanup_protection_ = value;
}
inline void SatParameters::set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value) {
  _internal_set_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::_internal_has_clause_cleanup_lbd_bound() const {
  bool value = (_has_bits_[2] & 0x00000400u) != 0;
  return value;
}
inline bool SatParameters::has_clause_cleanup_lbd_bound() const {
  return _internal_has_clause_cleanup_lbd_bound();
}
inline void SatParameters::clear_clause_cleanup_lbd_bound() {
  clause_cleanup_lbd_bound_ = 5;
  _has_bits_[2] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_lbd_bound() const {
  return clause_cleanup_lbd_bound_;
}
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 _internal_clause_cleanup_lbd_bound();
}
inline void SatParameters::_internal_set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000400u;
  clause_cleanup_lbd_bound_ = value;
}
inline void SatParameters::set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_clause_cleanup_ordering() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool SatParameters::has_clause_cleanup_ordering() const {
  return _internal_has_clause_cleanup_ordering();
}
inline void SatParameters::clear_clause_cleanup_ordering() {
  clause_cleanup_ordering_ = 0;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::operations_research::sat::SatParameters_ClauseOrdering SatParameters::_internal_clause_cleanup_ordering() const {
  return static_cast< ::operations_research::sat::SatParameters_ClauseOrdering >(clause_cleanup_ordering_);
}
inline ::operations_research::sat::SatParameters_ClauseOrdering SatParameters::clause_cleanup_ordering() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_ordering)
  return _internal_clause_cleanup_ordering();
}
inline void SatParameters::_internal_set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
  assert(::operations_research::sat::SatParameters_ClauseOrdering_IsValid(value));
  _has_bits_[0] |= 0x00000040u;
  clause_cleanup_ordering_ = value;
}
inline void SatParameters::set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
  _internal_set_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::_internal_has_pb_cleanup_increment() const {
  bool value = (_has_bits_[2] & 0x00000010u) != 0;
  return value;
}
inline bool SatParameters::has_pb_cleanup_increment() const {
  return _internal_has_pb_cleanup_increment();
}
inline void SatParameters::clear_pb_cleanup_increment() {
  pb_cleanup_increment_ = 200;
  _has_bits_[2] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_pb_cleanup_increment() const {
  return pb_cleanup_increment_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::pb_cleanup_increment() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pb_cleanup_increment)
  return _internal_pb_cleanup_increment();
}
inline void SatParameters::_internal_set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000010u;
  pb_cleanup_increment_ = value;
}
inline void SatParameters::set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_pb_cleanup_ratio() const {
  bool value = (_has_bits_[2] & 0x00000020u) != 0;
  return value;
}
inline bool SatParameters::has_pb_cleanup_ratio() const {
  return _internal_has_pb_cleanup_ratio();
}
inline void SatParameters::clear_pb_cleanup_ratio() {
  pb_cleanup_ratio_ = 0.5;
  _has_bits_[2] &= ~0x00000020u;
}
inline double SatParameters::_internal_pb_cleanup_ratio() const {
  return pb_cleanup_ratio_;
}
inline double SatParameters::pb_cleanup_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pb_cleanup_ratio)
  return _internal_pb_cleanup_ratio();
}
inline void SatParameters::_internal_set_pb_cleanup_ratio(double value) {
  _has_bits_[2] |= 0x00000020u;
  pb_cleanup_ratio_ = value;
}
inline void SatParameters::set_pb_cleanup_ratio(double value) {
  _internal_set_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::_internal_has_minimize_with_propagation_restart_period() const {
  bool value = (_has_bits_[2] & 0x10000000u) != 0;
  return value;
}
inline bool SatParameters::has_minimize_with_propagation_restart_period() const {
  return _internal_has_minimize_with_propagation_restart_period();
}
inline void SatParameters::clear_minimize_with_propagation_restart_period() {
  minimize_with_propagation_restart_period_ = 10;
  _has_bits_[2] &= ~0x10000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_minimize_with_propagation_restart_period() const {
  return minimize_with_propagation_restart_period_;
}
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 _internal_minimize_with_propagation_restart_period();
}
inline void SatParameters::_internal_set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x10000000u;
  minimize_with_propagation_restart_period_ = value;
}
inline void SatParameters::set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_minimize_with_propagation_num_decisions() const {
  bool value = (_has_bits_[2] & 0x20000000u) != 0;
  return value;
}
inline bool SatParameters::has_minimize_with_propagation_num_decisions() const {
  return _internal_has_minimize_with_propagation_num_decisions();
}
inline void SatParameters::clear_minimize_with_propagation_num_decisions() {
  minimize_with_propagation_num_decisions_ = 1000;
  _has_bits_[2] &= ~0x20000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_minimize_with_propagation_num_decisions() const {
  return minimize_with_propagation_num_decisions_;
}
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 _internal_minimize_with_propagation_num_decisions();
}
inline void SatParameters::_internal_set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x20000000u;
  minimize_with_propagation_num_decisions_ = value;
}
inline void SatParameters::set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_variable_activity_decay() const {
  bool value = (_has_bits_[1] & 0x00080000u) != 0;
  return value;
}
inline bool SatParameters::has_variable_activity_decay() const {
  return _internal_has_variable_activity_decay();
}
inline void SatParameters::clear_variable_activity_decay() {
  variable_activity_decay_ = 0.8;
  _has_bits_[1] &= ~0x00080000u;
}
inline double SatParameters::_internal_variable_activity_decay() const {
  return variable_activity_decay_;
}
inline double SatParameters::variable_activity_decay() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.variable_activity_decay)
  return _internal_variable_activity_decay();
}
inline void SatParameters::_internal_set_variable_activity_decay(double value) {
  _has_bits_[1] |= 0x00080000u;
  variable_activity_decay_ = value;
}
inline void SatParameters::set_variable_activity_decay(double value) {
  _internal_set_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::_internal_has_max_variable_activity_value() const {
  bool value = (_has_bits_[1] & 0x00100000u) != 0;
  return value;
}
inline bool SatParameters::has_max_variable_activity_value() const {
  return _internal_has_max_variable_activity_value();
}
inline void SatParameters::clear_max_variable_activity_value() {
  max_variable_activity_value_ = 1e+100;
  _has_bits_[1] &= ~0x00100000u;
}
inline double SatParameters::_internal_max_variable_activity_value() const {
  return max_variable_activity_value_;
}
inline double SatParameters::max_variable_activity_value() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_variable_activity_value)
  return _internal_max_variable_activity_value();
}
inline void SatParameters::_internal_set_max_variable_activity_value(double value) {
  _has_bits_[1] |= 0x00100000u;
  max_variable_activity_value_ = value;
}
inline void SatParameters::set_max_variable_activity_value(double value) {
  _internal_set_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::_internal_has_glucose_max_decay() const {
  bool value = (_has_bits_[1] & 0x00800000u) != 0;
  return value;
}
inline bool SatParameters::has_glucose_max_decay() const {
  return _internal_has_glucose_max_decay();
}
inline void SatParameters::clear_glucose_max_decay() {
  glucose_max_decay_ = 0.95;
  _has_bits_[1] &= ~0x00800000u;
}
inline double SatParameters::_internal_glucose_max_decay() const {
  return glucose_max_decay_;
}
inline double SatParameters::glucose_max_decay() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_max_decay)
  return _internal_glucose_max_decay();
}
inline void SatParameters::_internal_set_glucose_max_decay(double value) {
  _has_bits_[1] |= 0x00800000u;
  glucose_max_decay_ = value;
}
inline void SatParameters::set_glucose_max_decay(double value) {
  _internal_set_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::_internal_has_glucose_decay_increment() const {
  bool value = (_has_bits_[1] & 0x01000000u) != 0;
  return value;
}
inline bool SatParameters::has_glucose_decay_increment() const {
  return _internal_has_glucose_decay_increment();
}
inline void SatParameters::clear_glucose_decay_increment() {
  glucose_decay_increment_ = 0.01;
  _has_bits_[1] &= ~0x01000000u;
}
inline double SatParameters::_internal_glucose_decay_increment() const {
  return glucose_decay_increment_;
}
inline double SatParameters::glucose_decay_increment() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_decay_increment)
  return _internal_glucose_decay_increment();
}
inline void SatParameters::_internal_set_glucose_decay_increment(double value) {
  _has_bits_[1] |= 0x01000000u;
  glucose_decay_increment_ = value;
}
inline void SatParameters::set_glucose_decay_increment(double value) {
  _internal_set_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::_internal_has_glucose_decay_increment_period() const {
  bool value = (_has_bits_[1] & 0x02000000u) != 0;
  return value;
}
inline bool SatParameters::has_glucose_decay_increment_period() const {
  return _internal_has_glucose_decay_increment_period();
}
inline void SatParameters::clear_glucose_decay_increment_period() {
  glucose_decay_increment_period_ = 5000;
  _has_bits_[1] &= ~0x02000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_glucose_decay_increment_period() const {
  return glucose_decay_increment_period_;
}
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 _internal_glucose_decay_increment_period();
}
inline void SatParameters::_internal_set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x02000000u;
  glucose_decay_increment_period_ = value;
}
inline void SatParameters::set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_clause_activity_decay() const {
  bool value = (_has_bits_[1] & 0x00200000u) != 0;
  return value;
}
inline bool SatParameters::has_clause_activity_decay() const {
  return _internal_has_clause_activity_decay();
}
inline void SatParameters::clear_clause_activity_decay() {
  clause_activity_decay_ = 0.999;
  _has_bits_[1] &= ~0x00200000u;
}
inline double SatParameters::_internal_clause_activity_decay() const {
  return clause_activity_decay_;
}
inline double SatParameters::clause_activity_decay() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_activity_decay)
  return _internal_clause_activity_decay();
}
inline void SatParameters::_internal_set_clause_activity_decay(double value) {
  _has_bits_[1] |= 0x00200000u;
  clause_activity_decay_ = value;
}
inline void SatParameters::set_clause_activity_decay(double value) {
  _internal_set_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::_internal_has_max_clause_activity_value() const {
  bool value = (_has_bits_[1] & 0x00400000u) != 0;
  return value;
}
inline bool SatParameters::has_max_clause_activity_value() const {
  return _internal_has_max_clause_activity_value();
}
inline void SatParameters::clear_max_clause_activity_value() {
  max_clause_activity_value_ = 1e+20;
  _has_bits_[1] &= ~0x00400000u;
}
inline double SatParameters::_internal_max_clause_activity_value() const {
  return max_clause_activity_value_;
}
inline double SatParameters::max_clause_activity_value() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_clause_activity_value)
  return _internal_max_clause_activity_value();
}
inline void SatParameters::_internal_set_max_clause_activity_value(double value) {
  _has_bits_[1] |= 0x00400000u;
  max_clause_activity_value_ = value;
}
inline void SatParameters::set_max_clause_activity_value(double value) {
  _internal_set_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::_internal_restart_algorithms_size() const {
  return restart_algorithms_.size();
}
inline int SatParameters::restart_algorithms_size() const {
  return _internal_restart_algorithms_size();
}
inline void SatParameters::clear_restart_algorithms() {
  restart_algorithms_.Clear();
}
inline ::operations_research::sat::SatParameters_RestartAlgorithm SatParameters::_internal_restart_algorithms(int index) const {
  return static_cast< ::operations_research::sat::SatParameters_RestartAlgorithm >(restart_algorithms_.Get(index));
}
inline ::operations_research::sat::SatParameters_RestartAlgorithm SatParameters::restart_algorithms(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_algorithms)
  return _internal_restart_algorithms(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::_internal_add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value) {
  assert(::operations_research::sat::SatParameters_RestartAlgorithm_IsValid(value));
  restart_algorithms_.Add(value);
}
inline void SatParameters::add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value) {
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.restart_algorithms)
  _internal_add_restart_algorithms(value);
}
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::_internal_mutable_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 _internal_mutable_restart_algorithms();
}

// optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
inline bool SatParameters::_internal_has_default_restart_algorithms() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool SatParameters::has_default_restart_algorithms() const {
  return _internal_has_default_restart_algorithms();
}
inline void SatParameters::clear_default_restart_algorithms() {
  default_restart_algorithms_.ClearToDefault(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), GetArena());
  _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 _internal_default_restart_algorithms();
}
inline void SatParameters::set_default_restart_algorithms(const std::string& value) {
  _internal_set_default_restart_algorithms(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline std::string* SatParameters::mutable_default_restart_algorithms() {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.default_restart_algorithms)
  return _internal_mutable_default_restart_algorithms();
}
inline const std::string& SatParameters::_internal_default_restart_algorithms() const {
  return default_restart_algorithms_.Get();
}
inline void SatParameters::_internal_set_default_restart_algorithms(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  default_restart_algorithms_.Set(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), value, GetArena());
}
inline void SatParameters::set_default_restart_algorithms(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  default_restart_algorithms_.Set(
    &::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), ::std::move(value), GetArena());
  // @@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_.Set(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), ::std::string(value),
              GetArena());
  // @@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_.Set(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline std::string* SatParameters::_internal_mutable_default_restart_algorithms() {
  _has_bits_[0] |= 0x00000001u;
  return default_restart_algorithms_.Mutable(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), GetArena());
}
inline std::string* SatParameters::release_default_restart_algorithms() {
  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.default_restart_algorithms)
  if (!_internal_has_default_restart_algorithms()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return default_restart_algorithms_.ReleaseNonDefault(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), GetArena());
}
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_.SetAllocated(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(), default_restart_algorithms,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline std::string* SatParameters::unsafe_arena_release_default_restart_algorithms() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.sat.SatParameters.default_restart_algorithms)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000001u;
  return default_restart_algorithms_.UnsafeArenaRelease(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(),
      GetArena());
}
inline void SatParameters::unsafe_arena_set_allocated_default_restart_algorithms(
    std::string* default_restart_algorithms) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (default_restart_algorithms != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  default_restart_algorithms_.UnsafeArenaSetAllocated(&::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get(),
      default_restart_algorithms, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.sat.SatParameters.default_restart_algorithms)
}

// optional int32 restart_period = 30 [default = 50];
inline bool SatParameters::_internal_has_restart_period() const {
  bool value = (_has_bits_[1] & 0x04000000u) != 0;
  return value;
}
inline bool SatParameters::has_restart_period() const {
  return _internal_has_restart_period();
}
inline void SatParameters::clear_restart_period() {
  restart_period_ = 50;
  _has_bits_[1] &= ~0x04000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_restart_period() const {
  return restart_period_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::restart_period() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_period)
  return _internal_restart_period();
}
inline void SatParameters::_internal_set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x04000000u;
  restart_period_ = value;
}
inline void SatParameters::set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_restart_running_window_size() const {
  bool value = (_has_bits_[2] & 0x00001000u) != 0;
  return value;
}
inline bool SatParameters::has_restart_running_window_size() const {
  return _internal_has_restart_running_window_size();
}
inline void SatParameters::clear_restart_running_window_size() {
  restart_running_window_size_ = 50;
  _has_bits_[2] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_restart_running_window_size() const {
  return restart_running_window_size_;
}
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 _internal_restart_running_window_size();
}
inline void SatParameters::_internal_set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00001000u;
  restart_running_window_size_ = value;
}
inline void SatParameters::set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_restart_dl_average_ratio() const {
  bool value = (_has_bits_[2] & 0x00000800u) != 0;
  return value;
}
inline bool SatParameters::has_restart_dl_average_ratio() const {
  return _internal_has_restart_dl_average_ratio();
}
inline void SatParameters::clear_restart_dl_average_ratio() {
  restart_dl_average_ratio_ = 1;
  _has_bits_[2] &= ~0x00000800u;
}
inline double SatParameters::_internal_restart_dl_average_ratio() const {
  return restart_dl_average_ratio_;
}
inline double SatParameters::restart_dl_average_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_dl_average_ratio)
  return _internal_restart_dl_average_ratio();
}
inline void SatParameters::_internal_set_restart_dl_average_ratio(double value) {
  _has_bits_[2] |= 0x00000800u;
  restart_dl_average_ratio_ = value;
}
inline void SatParameters::set_restart_dl_average_ratio(double value) {
  _internal_set_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::_internal_has_restart_lbd_average_ratio() const {
  bool value = (_has_bits_[2] & 0x00010000u) != 0;
  return value;
}
inline bool SatParameters::has_restart_lbd_average_ratio() const {
  return _internal_has_restart_lbd_average_ratio();
}
inline void SatParameters::clear_restart_lbd_average_ratio() {
  restart_lbd_average_ratio_ = 1;
  _has_bits_[2] &= ~0x00010000u;
}
inline double SatParameters::_internal_restart_lbd_average_ratio() const {
  return restart_lbd_average_ratio_;
}
inline double SatParameters::restart_lbd_average_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_lbd_average_ratio)
  return _internal_restart_lbd_average_ratio();
}
inline void SatParameters::_internal_set_restart_lbd_average_ratio(double value) {
  _has_bits_[2] |= 0x00010000u;
  restart_lbd_average_ratio_ = value;
}
inline void SatParameters::set_restart_lbd_average_ratio(double value) {
  _internal_set_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::_internal_has_use_blocking_restart() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool SatParameters::has_use_blocking_restart() const {
  return _internal_has_use_blocking_restart();
}
inline void SatParameters::clear_use_blocking_restart() {
  use_blocking_restart_ = false;
  _has_bits_[0] &= ~0x00000200u;
}
inline bool SatParameters::_internal_use_blocking_restart() const {
  return use_blocking_restart_;
}
inline bool SatParameters::use_blocking_restart() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_blocking_restart)
  return _internal_use_blocking_restart();
}
inline void SatParameters::_internal_set_use_blocking_restart(bool value) {
  _has_bits_[0] |= 0x00000200u;
  use_blocking_restart_ = value;
}
inline void SatParameters::set_use_blocking_restart(bool value) {
  _internal_set_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::_internal_has_blocking_restart_window_size() const {
  bool value = (_has_bits_[2] & 0x00002000u) != 0;
  return value;
}
inline bool SatParameters::has_blocking_restart_window_size() const {
  return _internal_has_blocking_restart_window_size();
}
inline void SatParameters::clear_blocking_restart_window_size() {
  blocking_restart_window_size_ = 5000;
  _has_bits_[2] &= ~0x00002000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_blocking_restart_window_size() const {
  return blocking_restart_window_size_;
}
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 _internal_blocking_restart_window_size();
}
inline void SatParameters::_internal_set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00002000u;
  blocking_restart_window_size_ = value;
}
inline void SatParameters::set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_blocking_restart_multiplier() const {
  bool value = (_has_bits_[2] & 0x00004000u) != 0;
  return value;
}
inline bool SatParameters::has_blocking_restart_multiplier() const {
  return _internal_has_blocking_restart_multiplier();
}
inline void SatParameters::clear_blocking_restart_multiplier() {
  blocking_restart_multiplier_ = 1.4;
  _has_bits_[2] &= ~0x00004000u;
}
inline double SatParameters::_internal_blocking_restart_multiplier() const {
  return blocking_restart_multiplier_;
}
inline double SatParameters::blocking_restart_multiplier() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.blocking_restart_multiplier)
  return _internal_blocking_restart_multiplier();
}
inline void SatParameters::_internal_set_blocking_restart_multiplier(double value) {
  _has_bits_[2] |= 0x00004000u;
  blocking_restart_multiplier_ = value;
}
inline void SatParameters::set_blocking_restart_multiplier(double value) {
  _internal_set_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::_internal_has_num_conflicts_before_strategy_changes() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool SatParameters::has_num_conflicts_before_strategy_changes() const {
  return _internal_has_num_conflicts_before_strategy_changes();
}
inline void SatParameters::clear_num_conflicts_before_strategy_changes() {
  num_conflicts_before_strategy_changes_ = 0;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_num_conflicts_before_strategy_changes() const {
  return num_conflicts_before_strategy_changes_;
}
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 _internal_num_conflicts_before_strategy_changes();
}
inline void SatParameters::_internal_set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000800u;
  num_conflicts_before_strategy_changes_ = value;
}
inline void SatParameters::set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_strategy_change_increase_ratio() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool SatParameters::has_strategy_change_increase_ratio() const {
  return _internal_has_strategy_change_increase_ratio();
}
inline void SatParameters::clear_strategy_change_increase_ratio() {
  strategy_change_increase_ratio_ = 0;
  _has_bits_[0] &= ~0x00001000u;
}
inline double SatParameters::_internal_strategy_change_increase_ratio() const {
  return strategy_change_increase_ratio_;
}
inline double SatParameters::strategy_change_increase_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.strategy_change_increase_ratio)
  return _internal_strategy_change_increase_ratio();
}
inline void SatParameters::_internal_set_strategy_change_increase_ratio(double value) {
  _has_bits_[0] |= 0x00001000u;
  strategy_change_increase_ratio_ = value;
}
inline void SatParameters::set_strategy_change_increase_ratio(double value) {
  _internal_set_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::_internal_has_max_time_in_seconds() const {
  bool value = (_has_bits_[1] & 0x20000000u) != 0;
  return value;
}
inline bool SatParameters::has_max_time_in_seconds() const {
  return _internal_has_max_time_in_seconds();
}
inline void SatParameters::clear_max_time_in_seconds() {
  max_time_in_seconds_ = std::numeric_limits<double>::infinity();
  _has_bits_[1] &= ~0x20000000u;
}
inline double SatParameters::_internal_max_time_in_seconds() const {
  return max_time_in_seconds_;
}
inline double SatParameters::max_time_in_seconds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_time_in_seconds)
  return _internal_max_time_in_seconds();
}
inline void SatParameters::_internal_set_max_time_in_seconds(double value) {
  _has_bits_[1] |= 0x20000000u;
  max_time_in_seconds_ = value;
}
inline void SatParameters::set_max_time_in_seconds(double value) {
  _internal_set_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::_internal_has_max_deterministic_time() const {
  bool value = (_has_bits_[2] & 0x00008000u) != 0;
  return value;
}
inline bool SatParameters::has_max_deterministic_time() const {
  return _internal_has_max_deterministic_time();
}
inline void SatParameters::clear_max_deterministic_time() {
  max_deterministic_time_ = std::numeric_limits<double>::infinity();
  _has_bits_[2] &= ~0x00008000u;
}
inline double SatParameters::_internal_max_deterministic_time() const {
  return max_deterministic_time_;
}
inline double SatParameters::max_deterministic_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_deterministic_time)
  return _internal_max_deterministic_time();
}
inline void SatParameters::_internal_set_max_deterministic_time(double value) {
  _has_bits_[2] |= 0x00008000u;
  max_deterministic_time_ = value;
}
inline void SatParameters::set_max_deterministic_time(double value) {
  _internal_set_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::_internal_has_max_number_of_conflicts() const {
  bool value = (_has_bits_[1] & 0x40000000u) != 0;
  return value;
}
inline bool SatParameters::has_max_number_of_conflicts() const {
  return _internal_has_max_number_of_conflicts();
}
inline void SatParameters::clear_max_number_of_conflicts() {
  max_number_of_conflicts_ = PROTOBUF_LONGLONG(9223372036854775807);
  _has_bits_[1] &= ~0x40000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_max_number_of_conflicts() const {
  return max_number_of_conflicts_;
}
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 _internal_max_number_of_conflicts();
}
inline void SatParameters::_internal_set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[1] |= 0x40000000u;
  max_number_of_conflicts_ = value;
}
inline void SatParameters::set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_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::_internal_has_max_memory_in_mb() const {
  bool value = (_has_bits_[1] & 0x80000000u) != 0;
  return value;
}
inline bool SatParameters::has_max_memory_in_mb() const {
  return _internal_has_max_memory_in_mb();
}
inline void SatParameters::clear_max_memory_in_mb() {
  max_memory_in_mb_ = PROTOBUF_LONGLONG(10000);
  _has_bits_[1] &= ~0x80000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_max_memory_in_mb() const {
  return max_memory_in_mb_;
}
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 _internal_max_memory_in_mb();
}
inline void SatParameters::_internal_set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[1] |= 0x80000000u;
  max_memory_in_mb_ = value;
}
inline void SatParameters::set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_max_memory_in_mb(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_memory_in_mb)
}

// optional double absolute_gap_limit = 159 [default = 0];
inline bool SatParameters::_internal_has_absolute_gap_limit() const {
  bool value = (_has_bits_[1] & 0x00001000u) != 0;
  return value;
}
inline bool SatParameters::has_absolute_gap_limit() const {
  return _internal_has_absolute_gap_limit();
}
inline void SatParameters::clear_absolute_gap_limit() {
  absolute_gap_limit_ = 0;
  _has_bits_[1] &= ~0x00001000u;
}
inline double SatParameters::_internal_absolute_gap_limit() const {
  return absolute_gap_limit_;
}
inline double SatParameters::absolute_gap_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.absolute_gap_limit)
  return _internal_absolute_gap_limit();
}
inline void SatParameters::_internal_set_absolute_gap_limit(double value) {
  _has_bits_[1] |= 0x00001000u;
  absolute_gap_limit_ = value;
}
inline void SatParameters::set_absolute_gap_limit(double value) {
  _internal_set_absolute_gap_limit(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.absolute_gap_limit)
}

// optional double relative_gap_limit = 160 [default = 0];
inline bool SatParameters::_internal_has_relative_gap_limit() const {
  bool value = (_has_bits_[1] & 0x00002000u) != 0;
  return value;
}
inline bool SatParameters::has_relative_gap_limit() const {
  return _internal_has_relative_gap_limit();
}
inline void SatParameters::clear_relative_gap_limit() {
  relative_gap_limit_ = 0;
  _has_bits_[1] &= ~0x00002000u;
}
inline double SatParameters::_internal_relative_gap_limit() const {
  return relative_gap_limit_;
}
inline double SatParameters::relative_gap_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.relative_gap_limit)
  return _internal_relative_gap_limit();
}
inline void SatParameters::_internal_set_relative_gap_limit(double value) {
  _has_bits_[1] |= 0x00002000u;
  relative_gap_limit_ = value;
}
inline void SatParameters::set_relative_gap_limit(double value) {
  _internal_set_relative_gap_limit(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.relative_gap_limit)
}

// optional bool treat_binary_clauses_separately = 33 [default = true];
inline bool SatParameters::_internal_has_treat_binary_clauses_separately() const {
  bool value = (_has_bits_[2] & 0x00000004u) != 0;
  return value;
}
inline bool SatParameters::has_treat_binary_clauses_separately() const {
  return _internal_has_treat_binary_clauses_separately();
}
inline void SatParameters::clear_treat_binary_clauses_separately() {
  treat_binary_clauses_separately_ = true;
  _has_bits_[2] &= ~0x00000004u;
}
inline bool SatParameters::_internal_treat_binary_clauses_separately() const {
  return treat_binary_clauses_separately_;
}
inline bool SatParameters::treat_binary_clauses_separately() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.treat_binary_clauses_separately)
  return _internal_treat_binary_clauses_separately();
}
inline void SatParameters::_internal_set_treat_binary_clauses_separately(bool value) {
  _has_bits_[2] |= 0x00000004u;
  treat_binary_clauses_separately_ = value;
}
inline void SatParameters::set_treat_binary_clauses_separately(bool value) {
  _internal_set_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::_internal_has_random_seed() const {
  bool value = (_has_bits_[1] & 0x08000000u) != 0;
  return value;
}
inline bool SatParameters::has_random_seed() const {
  return _internal_has_random_seed();
}
inline void SatParameters::clear_random_seed() {
  random_seed_ = 1;
  _has_bits_[1] &= ~0x08000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_random_seed() const {
  return random_seed_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::random_seed() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_seed)
  return _internal_random_seed();
}
inline void SatParameters::_internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x08000000u;
  random_seed_ = value;
}
inline void SatParameters::set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_log_search_progress() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool SatParameters::has_log_search_progress() const {
  return _internal_has_log_search_progress();
}
inline void SatParameters::clear_log_search_progress() {
  log_search_progress_ = false;
  _has_bits_[0] &= ~0x00000400u;
}
inline bool SatParameters::_internal_log_search_progress() const {
  return log_search_progress_;
}
inline bool SatParameters::log_search_progress() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_search_progress)
  return _internal_log_search_progress();
}
inline void SatParameters::_internal_set_log_search_progress(bool value) {
  _has_bits_[0] |= 0x00000400u;
  log_search_progress_ = value;
}
inline void SatParameters::set_log_search_progress(bool value) {
  _internal_set_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::_internal_has_use_pb_resolution() const {
  bool value = (_has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool SatParameters::has_use_pb_resolution() const {
  return _internal_has_use_pb_resolution();
}
inline void SatParameters::clear_use_pb_resolution() {
  use_pb_resolution_ = false;
  _has_bits_[0] &= ~0x00800000u;
}
inline bool SatParameters::_internal_use_pb_resolution() const {
  return use_pb_resolution_;
}
inline bool SatParameters::use_pb_resolution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_pb_resolution)
  return _internal_use_pb_resolution();
}
inline void SatParameters::_internal_set_use_pb_resolution(bool value) {
  _has_bits_[0] |= 0x00800000u;
  use_pb_resolution_ = value;
}
inline void SatParameters::set_use_pb_resolution(bool value) {
  _internal_set_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::_internal_has_minimize_reduction_during_pb_resolution() const {
  bool value = (_has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool SatParameters::has_minimize_reduction_during_pb_resolution() const {
  return _internal_has_minimize_reduction_during_pb_resolution();
}
inline void SatParameters::clear_minimize_reduction_during_pb_resolution() {
  minimize_reduction_during_pb_resolution_ = false;
  _has_bits_[0] &= ~0x01000000u;
}
inline bool SatParameters::_internal_minimize_reduction_during_pb_resolution() const {
  return minimize_reduction_during_pb_resolution_;
}
inline bool SatParameters::minimize_reduction_during_pb_resolution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_reduction_during_pb_resolution)
  return _internal_minimize_reduction_during_pb_resolution();
}
inline void SatParameters::_internal_set_minimize_reduction_during_pb_resolution(bool value) {
  _has_bits_[0] |= 0x01000000u;
  minimize_reduction_during_pb_resolution_ = value;
}
inline void SatParameters::set_minimize_reduction_during_pb_resolution(bool value) {
  _internal_set_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::_internal_has_count_assumption_levels_in_lbd() const {
  bool value = (_has_bits_[2] & 0x00000008u) != 0;
  return value;
}
inline bool SatParameters::has_count_assumption_levels_in_lbd() const {
  return _internal_has_count_assumption_levels_in_lbd();
}
inline void SatParameters::clear_count_assumption_levels_in_lbd() {
  count_assumption_levels_in_lbd_ = true;
  _has_bits_[2] &= ~0x00000008u;
}
inline bool SatParameters::_internal_count_assumption_levels_in_lbd() const {
  return count_assumption_levels_in_lbd_;
}
inline bool SatParameters::count_assumption_levels_in_lbd() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.count_assumption_levels_in_lbd)
  return _internal_count_assumption_levels_in_lbd();
}
inline void SatParameters::_internal_set_count_assumption_levels_in_lbd(bool value) {
  _has_bits_[2] |= 0x00000008u;
  count_assumption_levels_in_lbd_ = value;
}
inline void SatParameters::set_count_assumption_levels_in_lbd(bool value) {
  _internal_set_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::_internal_has_presolve_bve_threshold() const {
  bool value = (_has_bits_[2] & 0x00000080u) != 0;
  return value;
}
inline bool SatParameters::has_presolve_bve_threshold() const {
  return _internal_has_presolve_bve_threshold();
}
inline void SatParameters::clear_presolve_bve_threshold() {
  presolve_bve_threshold_ = 500;
  _has_bits_[2] &= ~0x00000080u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bve_threshold() const {
  return presolve_bve_threshold_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bve_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bve_threshold)
  return _internal_presolve_bve_threshold();
}
inline void SatParameters::_internal_set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000080u;
  presolve_bve_threshold_ = value;
}
inline void SatParameters::set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_presolve_bve_clause_weight() const {
  bool value = (_has_bits_[2] & 0x00000200u) != 0;
  return value;
}
inline bool SatParameters::has_presolve_bve_clause_weight() const {
  return _internal_has_presolve_bve_clause_weight();
}
inline void SatParameters::clear_presolve_bve_clause_weight() {
  presolve_bve_clause_weight_ = 3;
  _has_bits_[2] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bve_clause_weight() const {
  return presolve_bve_clause_weight_;
}
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 _internal_presolve_bve_clause_weight();
}
inline void SatParameters::_internal_set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000200u;
  presolve_bve_clause_weight_ = value;
}
inline void SatParameters::set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_presolve_probing_deterministic_time_limit() const {
  bool value = (_has_bits_[2] & 0x00000100u) != 0;
  return value;
}
inline bool SatParameters::has_presolve_probing_deterministic_time_limit() const {
  return _internal_has_presolve_probing_deterministic_time_limit();
}
inline void SatParameters::clear_presolve_probing_deterministic_time_limit() {
  presolve_probing_deterministic_time_limit_ = 30;
  _has_bits_[2] &= ~0x00000100u;
}
inline double SatParameters::_internal_presolve_probing_deterministic_time_limit() const {
  return presolve_probing_deterministic_time_limit_;
}
inline double SatParameters::presolve_probing_deterministic_time_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_probing_deterministic_time_limit)
  return _internal_presolve_probing_deterministic_time_limit();
}
inline void SatParameters::_internal_set_presolve_probing_deterministic_time_limit(double value) {
  _has_bits_[2] |= 0x00000100u;
  presolve_probing_deterministic_time_limit_ = value;
}
inline void SatParameters::set_presolve_probing_deterministic_time_limit(double value) {
  _internal_set_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::_internal_has_presolve_blocked_clause() const {
  bool value = (_has_bits_[2] & 0x00400000u) != 0;
  return value;
}
inline bool SatParameters::has_presolve_blocked_clause() const {
  return _internal_has_presolve_blocked_clause();
}
inline void SatParameters::clear_presolve_blocked_clause() {
  presolve_blocked_clause_ = true;
  _has_bits_[2] &= ~0x00400000u;
}
inline bool SatParameters::_internal_presolve_blocked_clause() const {
  return presolve_blocked_clause_;
}
inline bool SatParameters::presolve_blocked_clause() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_blocked_clause)
  return _internal_presolve_blocked_clause();
}
inline void SatParameters::_internal_set_presolve_blocked_clause(bool value) {
  _has_bits_[2] |= 0x00400000u;
  presolve_blocked_clause_ = value;
}
inline void SatParameters::set_presolve_blocked_clause(bool value) {
  _internal_set_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::_internal_has_presolve_use_bva() const {
  bool value = (_has_bits_[2] & 0x00800000u) != 0;
  return value;
}
inline bool SatParameters::has_presolve_use_bva() const {
  return _internal_has_presolve_use_bva();
}
inline void SatParameters::clear_presolve_use_bva() {
  presolve_use_bva_ = true;
  _has_bits_[2] &= ~0x00800000u;
}
inline bool SatParameters::_internal_presolve_use_bva() const {
  return presolve_use_bva_;
}
inline bool SatParameters::presolve_use_bva() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_use_bva)
  return _internal_presolve_use_bva();
}
inline void SatParameters::_internal_set_presolve_use_bva(bool value) {
  _has_bits_[2] |= 0x00800000u;
  presolve_use_bva_ = value;
}
inline void SatParameters::set_presolve_use_bva(bool value) {
  _internal_set_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::_internal_has_presolve_bva_threshold() const {
  bool value = (_has_bits_[2] & 0x00020000u) != 0;
  return value;
}
inline bool SatParameters::has_presolve_bva_threshold() const {
  return _internal_has_presolve_bva_threshold();
}
inline void SatParameters::clear_presolve_bva_threshold() {
  presolve_bva_threshold_ = 1;
  _has_bits_[2] &= ~0x00020000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bva_threshold() const {
  return presolve_bva_threshold_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bva_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bva_threshold)
  return _internal_presolve_bva_threshold();
}
inline void SatParameters::_internal_set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00020000u;
  presolve_bva_threshold_ = value;
}
inline void SatParameters::set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_presolve_bva_threshold(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bva_threshold)
}

// optional int32 max_presolve_iterations = 138 [default = 3];
inline bool SatParameters::_internal_has_max_presolve_iterations() const {
  bool value = (_has_bits_[4] & 0x00000002u) != 0;
  return value;
}
inline bool SatParameters::has_max_presolve_iterations() const {
  return _internal_has_max_presolve_iterations();
}
inline void SatParameters::clear_max_presolve_iterations() {
  max_presolve_iterations_ = 3;
  _has_bits_[4] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_presolve_iterations() const {
  return max_presolve_iterations_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_presolve_iterations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_presolve_iterations)
  return _internal_max_presolve_iterations();
}
inline void SatParameters::_internal_set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00000002u;
  max_presolve_iterations_ = value;
}
inline void SatParameters::set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_max_presolve_iterations(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_presolve_iterations)
}

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

// optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
inline bool SatParameters::_internal_has_cp_model_postsolve_with_full_solver() const {
  bool value = (_has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool SatParameters::has_cp_model_postsolve_with_full_solver() const {
  return _internal_has_cp_model_postsolve_with_full_solver();
}
inline void SatParameters::clear_cp_model_postsolve_with_full_solver() {
  cp_model_postsolve_with_full_solver_ = false;
  _has_bits_[0] &= ~0x02000000u;
}
inline bool SatParameters::_internal_cp_model_postsolve_with_full_solver() const {
  return cp_model_postsolve_with_full_solver_;
}
inline bool SatParameters::cp_model_postsolve_with_full_solver() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_postsolve_with_full_solver)
  return _internal_cp_model_postsolve_with_full_solver();
}
inline void SatParameters::_internal_set_cp_model_postsolve_with_full_solver(bool value) {
  _has_bits_[0] |= 0x02000000u;
  cp_model_postsolve_with_full_solver_ = value;
}
inline void SatParameters::set_cp_model_postsolve_with_full_solver(bool value) {
  _internal_set_cp_model_postsolve_with_full_solver(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_postsolve_with_full_solver)
}

// optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
inline bool SatParameters::_internal_has_cp_model_max_num_presolve_operations() const {
  bool value = (_has_bits_[1] & 0x00000800u) != 0;
  return value;
}
inline bool SatParameters::has_cp_model_max_num_presolve_operations() const {
  return _internal_has_cp_model_max_num_presolve_operations();
}
inline void SatParameters::clear_cp_model_max_num_presolve_operations() {
  cp_model_max_num_presolve_operations_ = 0;
  _has_bits_[1] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cp_model_max_num_presolve_operations() const {
  return cp_model_max_num_presolve_operations_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cp_model_max_num_presolve_operations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_max_num_presolve_operations)
  return _internal_cp_model_max_num_presolve_operations();
}
inline void SatParameters::_internal_set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00000800u;
  cp_model_max_num_presolve_operations_ = value;
}
inline void SatParameters::set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_cp_model_max_num_presolve_operations(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_max_num_presolve_operations)
}

// optional int32 cp_model_probing_level = 110 [default = 2];
inline bool SatParameters::_internal_has_cp_model_probing_level() const {
  bool value = (_has_bits_[3] & 0x00000020u) != 0;
  return value;
}
inline bool SatParameters::has_cp_model_probing_level() const {
  return _internal_has_cp_model_probing_level();
}
inline void SatParameters::clear_cp_model_probing_level() {
  cp_model_probing_level_ = 2;
  _has_bits_[3] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cp_model_probing_level() const {
  return cp_model_probing_level_;
}
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 _internal_cp_model_probing_level();
}
inline void SatParameters::_internal_set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00000020u;
  cp_model_probing_level_ = value;
}
inline void SatParameters::set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_cp_model_use_sat_presolve() const {
  bool value = (_has_bits_[2] & 0x02000000u) != 0;
  return value;
}
inline bool SatParameters::has_cp_model_use_sat_presolve() const {
  return _internal_has_cp_model_use_sat_presolve();
}
inline void SatParameters::clear_cp_model_use_sat_presolve() {
  cp_model_use_sat_presolve_ = true;
  _has_bits_[2] &= ~0x02000000u;
}
inline bool SatParameters::_internal_cp_model_use_sat_presolve() const {
  return cp_model_use_sat_presolve_;
}
inline bool SatParameters::cp_model_use_sat_presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
  return _internal_cp_model_use_sat_presolve();
}
inline void SatParameters::_internal_set_cp_model_use_sat_presolve(bool value) {
  _has_bits_[2] |= 0x02000000u;
  cp_model_use_sat_presolve_ = value;
}
inline void SatParameters::set_cp_model_use_sat_presolve(bool value) {
  _internal_set_cp_model_use_sat_presolve(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
}

// optional bool use_sat_inprocessing = 163 [default = false];
inline bool SatParameters::_internal_has_use_sat_inprocessing() const {
  bool value = (_has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool SatParameters::has_use_sat_inprocessing() const {
  return _internal_has_use_sat_inprocessing();
}
inline void SatParameters::clear_use_sat_inprocessing() {
  use_sat_inprocessing_ = false;
  _has_bits_[0] &= ~0x04000000u;
}
inline bool SatParameters::_internal_use_sat_inprocessing() const {
  return use_sat_inprocessing_;
}
inline bool SatParameters::use_sat_inprocessing() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_sat_inprocessing)
  return _internal_use_sat_inprocessing();
}
inline void SatParameters::_internal_set_use_sat_inprocessing(bool value) {
  _has_bits_[0] |= 0x04000000u;
  use_sat_inprocessing_ = value;
}
inline void SatParameters::set_use_sat_inprocessing(bool value) {
  _internal_set_use_sat_inprocessing(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_sat_inprocessing)
}

// optional bool expand_element_constraints = 140 [default = true];
inline bool SatParameters::_internal_has_expand_element_constraints() const {
  bool value = (_has_bits_[3] & 0x00010000u) != 0;
  return value;
}
inline bool SatParameters::has_expand_element_constraints() const {
  return _internal_has_expand_element_constraints();
}
inline void SatParameters::clear_expand_element_constraints() {
  expand_element_constraints_ = true;
  _has_bits_[3] &= ~0x00010000u;
}
inline bool SatParameters::_internal_expand_element_constraints() const {
  return expand_element_constraints_;
}
inline bool SatParameters::expand_element_constraints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_element_constraints)
  return _internal_expand_element_constraints();
}
inline void SatParameters::_internal_set_expand_element_constraints(bool value) {
  _has_bits_[3] |= 0x00010000u;
  expand_element_constraints_ = value;
}
inline void SatParameters::set_expand_element_constraints(bool value) {
  _internal_set_expand_element_constraints(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_element_constraints)
}

// optional bool expand_automaton_constraints = 143 [default = true];
inline bool SatParameters::_internal_has_expand_automaton_constraints() const {
  bool value = (_has_bits_[3] & 0x00020000u) != 0;
  return value;
}
inline bool SatParameters::has_expand_automaton_constraints() const {
  return _internal_has_expand_automaton_constraints();
}
inline void SatParameters::clear_expand_automaton_constraints() {
  expand_automaton_constraints_ = true;
  _has_bits_[3] &= ~0x00020000u;
}
inline bool SatParameters::_internal_expand_automaton_constraints() const {
  return expand_automaton_constraints_;
}
inline bool SatParameters::expand_automaton_constraints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_automaton_constraints)
  return _internal_expand_automaton_constraints();
}
inline void SatParameters::_internal_set_expand_automaton_constraints(bool value) {
  _has_bits_[3] |= 0x00020000u;
  expand_automaton_constraints_ = value;
}
inline void SatParameters::set_expand_automaton_constraints(bool value) {
  _internal_set_expand_automaton_constraints(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_automaton_constraints)
}

// optional bool expand_table_constraints = 158 [default = true];
inline bool SatParameters::_internal_has_expand_table_constraints() const {
  bool value = (_has_bits_[3] & 0x00040000u) != 0;
  return value;
}
inline bool SatParameters::has_expand_table_constraints() const {
  return _internal_has_expand_table_constraints();
}
inline void SatParameters::clear_expand_table_constraints() {
  expand_table_constraints_ = true;
  _has_bits_[3] &= ~0x00040000u;
}
inline bool SatParameters::_internal_expand_table_constraints() const {
  return expand_table_constraints_;
}
inline bool SatParameters::expand_table_constraints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_table_constraints)
  return _internal_expand_table_constraints();
}
inline void SatParameters::_internal_set_expand_table_constraints(bool value) {
  _has_bits_[3] |= 0x00040000u;
  expand_table_constraints_ = value;
}
inline void SatParameters::set_expand_table_constraints(bool value) {
  _internal_set_expand_table_constraints(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_table_constraints)
}

// optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
inline bool SatParameters::_internal_has_merge_no_overlap_work_limit() const {
  bool value = (_has_bits_[4] & 0x00000004u) != 0;
  return value;
}
inline bool SatParameters::has_merge_no_overlap_work_limit() const {
  return _internal_has_merge_no_overlap_work_limit();
}
inline void SatParameters::clear_merge_no_overlap_work_limit() {
  merge_no_overlap_work_limit_ = 1000000000000;
  _has_bits_[4] &= ~0x00000004u;
}
inline double SatParameters::_internal_merge_no_overlap_work_limit() const {
  return merge_no_overlap_work_limit_;
}
inline double SatParameters::merge_no_overlap_work_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.merge_no_overlap_work_limit)
  return _internal_merge_no_overlap_work_limit();
}
inline void SatParameters::_internal_set_merge_no_overlap_work_limit(double value) {
  _has_bits_[4] |= 0x00000004u;
  merge_no_overlap_work_limit_ = value;
}
inline void SatParameters::set_merge_no_overlap_work_limit(double value) {
  _internal_set_merge_no_overlap_work_limit(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.merge_no_overlap_work_limit)
}

// optional double merge_at_most_one_work_limit = 146 [default = 100000000];
inline bool SatParameters::_internal_has_merge_at_most_one_work_limit() const {
  bool value = (_has_bits_[4] & 0x00000008u) != 0;
  return value;
}
inline bool SatParameters::has_merge_at_most_one_work_limit() const {
  return _internal_has_merge_at_most_one_work_limit();
}
inline void SatParameters::clear_merge_at_most_one_work_limit() {
  merge_at_most_one_work_limit_ = 100000000;
  _has_bits_[4] &= ~0x00000008u;
}
inline double SatParameters::_internal_merge_at_most_one_work_limit() const {
  return merge_at_most_one_work_limit_;
}
inline double SatParameters::merge_at_most_one_work_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.merge_at_most_one_work_limit)
  return _internal_merge_at_most_one_work_limit();
}
inline void SatParameters::_internal_set_merge_at_most_one_work_limit(double value) {
  _has_bits_[4] |= 0x00000008u;
  merge_at_most_one_work_limit_ = value;
}
inline void SatParameters::set_merge_at_most_one_work_limit(double value) {
  _internal_set_merge_at_most_one_work_limit(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.merge_at_most_one_work_limit)
}

// optional int32 presolve_substitution_level = 147 [default = 1];
inline bool SatParameters::_internal_has_presolve_substitution_level() const {
  bool value = (_has_bits_[4] & 0x00000010u) != 0;
  return value;
}
inline bool SatParameters::has_presolve_substitution_level() const {
  return _internal_has_presolve_substitution_level();
}
inline void SatParameters::clear_presolve_substitution_level() {
  presolve_substitution_level_ = 1;
  _has_bits_[4] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_substitution_level() const {
  return presolve_substitution_level_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_substitution_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_substitution_level)
  return _internal_presolve_substitution_level();
}
inline void SatParameters::_internal_set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00000010u;
  presolve_substitution_level_ = value;
}
inline void SatParameters::set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_presolve_substitution_level(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_substitution_level)
}

// optional bool use_optimization_hints = 35 [default = true];
inline bool SatParameters::_internal_has_use_optimization_hints() const {
  bool value = (_has_bits_[3] & 0x00080000u) != 0;
  return value;
}
inline bool SatParameters::has_use_optimization_hints() const {
  return _internal_has_use_optimization_hints();
}
inline void SatParameters::clear_use_optimization_hints() {
  use_optimization_hints_ = true;
  _has_bits_[3] &= ~0x00080000u;
}
inline bool SatParameters::_internal_use_optimization_hints() const {
  return use_optimization_hints_;
}
inline bool SatParameters::use_optimization_hints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_optimization_hints)
  return _internal_use_optimization_hints();
}
inline void SatParameters::_internal_set_use_optimization_hints(bool value) {
  _has_bits_[3] |= 0x00080000u;
  use_optimization_hints_ = value;
}
inline void SatParameters::set_use_optimization_hints(bool value) {
  _internal_set_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::_internal_has_minimize_core() const {
  bool value = (_has_bits_[2] & 0x00040000u) != 0;
  return value;
}
inline bool SatParameters::has_minimize_core() const {
  return _internal_has_minimize_core();
}
inline void SatParameters::clear_minimize_core() {
  minimize_core_ = true;
  _has_bits_[2] &= ~0x00040000u;
}
inline bool SatParameters::_internal_minimize_core() const {
  return minimize_core_;
}
inline bool SatParameters::minimize_core() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_core)
  return _internal_minimize_core();
}
inline void SatParameters::_internal_set_minimize_core(bool value) {
  _has_bits_[2] |= 0x00040000u;
  minimize_core_ = value;
}
inline void SatParameters::set_minimize_core(bool value) {
  _internal_set_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::_internal_has_find_multiple_cores() const {
  bool value = (_has_bits_[2] & 0x00080000u) != 0;
  return value;
}
inline bool SatParameters::has_find_multiple_cores() const {
  return _internal_has_find_multiple_cores();
}
inline void SatParameters::clear_find_multiple_cores() {
  find_multiple_cores_ = true;
  _has_bits_[2] &= ~0x00080000u;
}
inline bool SatParameters::_internal_find_multiple_cores() const {
  return find_multiple_cores_;
}
inline bool SatParameters::find_multiple_cores() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.find_multiple_cores)
  return _internal_find_multiple_cores();
}
inline void SatParameters::_internal_set_find_multiple_cores(bool value) {
  _has_bits_[2] |= 0x00080000u;
  find_multiple_cores_ = value;
}
inline void SatParameters::set_find_multiple_cores(bool value) {
  _internal_set_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::_internal_has_cover_optimization() const {
  bool value = (_has_bits_[2] & 0x00100000u) != 0;
  return value;
}
inline bool SatParameters::has_cover_optimization() const {
  return _internal_has_cover_optimization();
}
inline void SatParameters::clear_cover_optimization() {
  cover_optimization_ = true;
  _has_bits_[2] &= ~0x00100000u;
}
inline bool SatParameters::_internal_cover_optimization() const {
  return cover_optimization_;
}
inline bool SatParameters::cover_optimization() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cover_optimization)
  return _internal_cover_optimization();
}
inline void SatParameters::_internal_set_cover_optimization(bool value) {
  _has_bits_[2] |= 0x00100000u;
  cover_optimization_ = value;
}
inline void SatParameters::set_cover_optimization(bool value) {
  _internal_set_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::_internal_has_max_sat_assumption_order() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SatParameters::has_max_sat_assumption_order() const {
  return _internal_has_max_sat_assumption_order();
}
inline void SatParameters::clear_max_sat_assumption_order() {
  max_sat_assumption_order_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::operations_research::sat::SatParameters_MaxSatAssumptionOrder SatParameters::_internal_max_sat_assumption_order() const {
  return static_cast< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder >(max_sat_assumption_order_);
}
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 _internal_max_sat_assumption_order();
}
inline void SatParameters::_internal_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;
}
inline void SatParameters::set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value) {
  _internal_set_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::_internal_has_max_sat_reverse_assumption_order() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool SatParameters::has_max_sat_reverse_assumption_order() const {
  return _internal_has_max_sat_reverse_assumption_order();
}
inline void SatParameters::clear_max_sat_reverse_assumption_order() {
  max_sat_reverse_assumption_order_ = false;
  _has_bits_[0] &= ~0x00004000u;
}
inline bool SatParameters::_internal_max_sat_reverse_assumption_order() const {
  return max_sat_reverse_assumption_order_;
}
inline bool SatParameters::max_sat_reverse_assumption_order() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_reverse_assumption_order)
  return _internal_max_sat_reverse_assumption_order();
}
inline void SatParameters::_internal_set_max_sat_reverse_assumption_order(bool value) {
  _has_bits_[0] |= 0x00004000u;
  max_sat_reverse_assumption_order_ = value;
}
inline void SatParameters::set_max_sat_reverse_assumption_order(bool value) {
  _internal_set_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::_internal_has_max_sat_stratification() const {
  bool value = (_has_bits_[2] & 0x00000040u) != 0;
  return value;
}
inline bool SatParameters::has_max_sat_stratification() const {
  return _internal_has_max_sat_stratification();
}
inline void SatParameters::clear_max_sat_stratification() {
  max_sat_stratification_ = 1;
  _has_bits_[2] &= ~0x00000040u;
}
inline ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm SatParameters::_internal_max_sat_stratification() const {
  return static_cast< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm >(max_sat_stratification_);
}
inline ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm SatParameters::max_sat_stratification() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_stratification)
  return _internal_max_sat_stratification();
}
inline void SatParameters::_internal_set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
  assert(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_IsValid(value));
  _has_bits_[2] |= 0x00000040u;
  max_sat_stratification_ = value;
}
inline void SatParameters::set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
  _internal_set_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::_internal_has_use_precedences_in_disjunctive_constraint() const {
  bool value = (_has_bits_[2] & 0x00200000u) != 0;
  return value;
}
inline bool SatParameters::has_use_precedences_in_disjunctive_constraint() const {
  return _internal_has_use_precedences_in_disjunctive_constraint();
}
inline void SatParameters::clear_use_precedences_in_disjunctive_constraint() {
  use_precedences_in_disjunctive_constraint_ = true;
  _has_bits_[2] &= ~0x00200000u;
}
inline bool SatParameters::_internal_use_precedences_in_disjunctive_constraint() const {
  return use_precedences_in_disjunctive_constraint_;
}
inline bool SatParameters::use_precedences_in_disjunctive_constraint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_precedences_in_disjunctive_constraint)
  return _internal_use_precedences_in_disjunctive_constraint();
}
inline void SatParameters::_internal_set_use_precedences_in_disjunctive_constraint(bool value) {
  _has_bits_[2] |= 0x00200000u;
  use_precedences_in_disjunctive_constraint_ = value;
}
inline void SatParameters::set_use_precedences_in_disjunctive_constraint(bool value) {
  _internal_set_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::_internal_has_use_overload_checker_in_cumulative_constraint() const {
  bool value = (_has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool SatParameters::has_use_overload_checker_in_cumulative_constraint() const {
  return _internal_has_use_overload_checker_in_cumulative_constraint();
}
inline void SatParameters::clear_use_overload_checker_in_cumulative_constraint() {
  use_overload_checker_in_cumulative_constraint_ = false;
  _has_bits_[0] &= ~0x00008000u;
}
inline bool SatParameters::_internal_use_overload_checker_in_cumulative_constraint() const {
  return use_overload_checker_in_cumulative_constraint_;
}
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 _internal_use_overload_checker_in_cumulative_constraint();
}
inline void SatParameters::_internal_set_use_overload_checker_in_cumulative_constraint(bool value) {
  _has_bits_[0] |= 0x00008000u;
  use_overload_checker_in_cumulative_constraint_ = value;
}
inline void SatParameters::set_use_overload_checker_in_cumulative_constraint(bool value) {
  _internal_set_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::_internal_has_use_timetable_edge_finding_in_cumulative_constraint() const {
  bool value = (_has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool SatParameters::has_use_timetable_edge_finding_in_cumulative_constraint() const {
  return _internal_has_use_timetable_edge_finding_in_cumulative_constraint();
}
inline void SatParameters::clear_use_timetable_edge_finding_in_cumulative_constraint() {
  use_timetable_edge_finding_in_cumulative_constraint_ = false;
  _has_bits_[0] &= ~0x00010000u;
}
inline bool SatParameters::_internal_use_timetable_edge_finding_in_cumulative_constraint() const {
  return use_timetable_edge_finding_in_cumulative_constraint_;
}
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 _internal_use_timetable_edge_finding_in_cumulative_constraint();
}
inline void SatParameters::_internal_set_use_timetable_edge_finding_in_cumulative_constraint(bool value) {
  _has_bits_[0] |= 0x00010000u;
  use_timetable_edge_finding_in_cumulative_constraint_ = value;
}
inline void SatParameters::set_use_timetable_edge_finding_in_cumulative_constraint(bool value) {
  _internal_set_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::_internal_has_use_disjunctive_constraint_in_cumulative_constraint() const {
  bool value = (_has_bits_[3] & 0x00000800u) != 0;
  return value;
}
inline bool SatParameters::has_use_disjunctive_constraint_in_cumulative_constraint() const {
  return _internal_has_use_disjunctive_constraint_in_cumulative_constraint();
}
inline void SatParameters::clear_use_disjunctive_constraint_in_cumulative_constraint() {
  use_disjunctive_constraint_in_cumulative_constraint_ = true;
  _has_bits_[3] &= ~0x00000800u;
}
inline bool SatParameters::_internal_use_disjunctive_constraint_in_cumulative_constraint() const {
  return use_disjunctive_constraint_in_cumulative_constraint_;
}
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 _internal_use_disjunctive_constraint_in_cumulative_constraint();
}
inline void SatParameters::_internal_set_use_disjunctive_constraint_in_cumulative_constraint(bool value) {
  _has_bits_[3] |= 0x00000800u;
  use_disjunctive_constraint_in_cumulative_constraint_ = value;
}
inline void SatParameters::set_use_disjunctive_constraint_in_cumulative_constraint(bool value) {
  _internal_set_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::_internal_has_linearization_level() const {
  bool value = (_has_bits_[2] & 0x04000000u) != 0;
  return value;
}
inline bool SatParameters::has_linearization_level() const {
  return _internal_has_linearization_level();
}
inline void SatParameters::clear_linearization_level() {
  linearization_level_ = 1;
  _has_bits_[2] &= ~0x04000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_linearization_level() const {
  return linearization_level_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::linearization_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.linearization_level)
  return _internal_linearization_level();
}
inline void SatParameters::_internal_set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x04000000u;
  linearization_level_ = value;
}
inline void SatParameters::set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_boolean_encoding_level() const {
  bool value = (_has_bits_[3] & 0x00000001u) != 0;
  return value;
}
inline bool SatParameters::has_boolean_encoding_level() const {
  return _internal_has_boolean_encoding_level();
}
inline void SatParameters::clear_boolean_encoding_level() {
  boolean_encoding_level_ = 1;
  _has_bits_[3] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_boolean_encoding_level() const {
  return boolean_encoding_level_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::boolean_encoding_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.boolean_encoding_level)
  return _internal_boolean_encoding_level();
}
inline void SatParameters::_internal_set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00000001u;
  boolean_encoding_level_ = value;
}
inline void SatParameters::set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_boolean_encoding_level(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.boolean_encoding_level)
}

// optional int32 max_num_cuts = 91 [default = 10000];
inline bool SatParameters::_internal_has_max_num_cuts() const {
  bool value = (_has_bits_[2] & 0x08000000u) != 0;
  return value;
}
inline bool SatParameters::has_max_num_cuts() const {
  return _internal_has_max_num_cuts();
}
inline void SatParameters::clear_max_num_cuts() {
  max_num_cuts_ = 10000;
  _has_bits_[2] &= ~0x08000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_num_cuts() const {
  return max_num_cuts_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_num_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_num_cuts)
  return _internal_max_num_cuts();
}
inline void SatParameters::_internal_set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x08000000u;
  max_num_cuts_ = value;
}
inline void SatParameters::set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_only_add_cuts_at_level_zero() const {
  bool value = (_has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool SatParameters::has_only_add_cuts_at_level_zero() const {
  return _internal_has_only_add_cuts_at_level_zero();
}
inline void SatParameters::clear_only_add_cuts_at_level_zero() {
  only_add_cuts_at_level_zero_ = false;
  _has_bits_[0] &= ~0x00020000u;
}
inline bool SatParameters::_internal_only_add_cuts_at_level_zero() const {
  return only_add_cuts_at_level_zero_;
}
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 _internal_only_add_cuts_at_level_zero();
}
inline void SatParameters::_internal_set_only_add_cuts_at_level_zero(bool value) {
  _has_bits_[0] |= 0x00020000u;
  only_add_cuts_at_level_zero_ = value;
}
inline void SatParameters::set_only_add_cuts_at_level_zero(bool value) {
  _internal_set_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::_internal_has_add_knapsack_cuts() const {
  bool value = (_has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool SatParameters::has_add_knapsack_cuts() const {
  return _internal_has_add_knapsack_cuts();
}
inline void SatParameters::clear_add_knapsack_cuts() {
  add_knapsack_cuts_ = false;
  _has_bits_[0] &= ~0x10000000u;
}
inline bool SatParameters::_internal_add_knapsack_cuts() const {
  return add_knapsack_cuts_;
}
inline bool SatParameters::add_knapsack_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_knapsack_cuts)
  return _internal_add_knapsack_cuts();
}
inline void SatParameters::_internal_set_add_knapsack_cuts(bool value) {
  _has_bits_[0] |= 0x10000000u;
  add_knapsack_cuts_ = value;
}
inline void SatParameters::set_add_knapsack_cuts(bool value) {
  _internal_set_add_knapsack_cuts(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_knapsack_cuts)
}

// optional bool add_cg_cuts = 117 [default = true];
inline bool SatParameters::_internal_has_add_cg_cuts() const {
  bool value = (_has_bits_[3] & 0x00001000u) != 0;
  return value;
}
inline bool SatParameters::has_add_cg_cuts() const {
  return _internal_has_add_cg_cuts();
}
inline void SatParameters::clear_add_cg_cuts() {
  add_cg_cuts_ = true;
  _has_bits_[3] &= ~0x00001000u;
}
inline bool SatParameters::_internal_add_cg_cuts() const {
  return add_cg_cuts_;
}
inline bool SatParameters::add_cg_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_cg_cuts)
  return _internal_add_cg_cuts();
}
inline void SatParameters::_internal_set_add_cg_cuts(bool value) {
  _has_bits_[3] |= 0x00001000u;
  add_cg_cuts_ = value;
}
inline void SatParameters::set_add_cg_cuts(bool value) {
  _internal_set_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::_internal_has_add_mir_cuts() const {
  bool value = (_has_bits_[3] & 0x00002000u) != 0;
  return value;
}
inline bool SatParameters::has_add_mir_cuts() const {
  return _internal_has_add_mir_cuts();
}
inline void SatParameters::clear_add_mir_cuts() {
  add_mir_cuts_ = true;
  _has_bits_[3] &= ~0x00002000u;
}
inline bool SatParameters::_internal_add_mir_cuts() const {
  return add_mir_cuts_;
}
inline bool SatParameters::add_mir_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_mir_cuts)
  return _internal_add_mir_cuts();
}
inline void SatParameters::_internal_set_add_mir_cuts(bool value) {
  _has_bits_[3] |= 0x00002000u;
  add_mir_cuts_ = value;
}
inline void SatParameters::set_add_mir_cuts(bool value) {
  _internal_set_add_mir_cuts(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_mir_cuts)
}

// optional int32 max_all_diff_cut_size = 148 [default = 7];
inline bool SatParameters::_internal_has_max_all_diff_cut_size() const {
  bool value = (_has_bits_[4] & 0x00000020u) != 0;
  return value;
}
inline bool SatParameters::has_max_all_diff_cut_size() const {
  return _internal_has_max_all_diff_cut_size();
}
inline void SatParameters::clear_max_all_diff_cut_size() {
  max_all_diff_cut_size_ = 7;
  _has_bits_[4] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_all_diff_cut_size() const {
  return max_all_diff_cut_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_all_diff_cut_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_all_diff_cut_size)
  return _internal_max_all_diff_cut_size();
}
inline void SatParameters::_internal_set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00000020u;
  max_all_diff_cut_size_ = value;
}
inline void SatParameters::set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_max_all_diff_cut_size(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_all_diff_cut_size)
}

// optional bool add_lin_max_cuts = 152 [default = true];
inline bool SatParameters::_internal_has_add_lin_max_cuts() const {
  bool value = (_has_bits_[3] & 0x00004000u) != 0;
  return value;
}
inline bool SatParameters::has_add_lin_max_cuts() const {
  return _internal_has_add_lin_max_cuts();
}
inline void SatParameters::clear_add_lin_max_cuts() {
  add_lin_max_cuts_ = true;
  _has_bits_[3] &= ~0x00004000u;
}
inline bool SatParameters::_internal_add_lin_max_cuts() const {
  return add_lin_max_cuts_;
}
inline bool SatParameters::add_lin_max_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_lin_max_cuts)
  return _internal_add_lin_max_cuts();
}
inline void SatParameters::_internal_set_add_lin_max_cuts(bool value) {
  _has_bits_[3] |= 0x00004000u;
  add_lin_max_cuts_ = value;
}
inline void SatParameters::set_add_lin_max_cuts(bool value) {
  _internal_set_add_lin_max_cuts(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_lin_max_cuts)
}

// optional int32 max_integer_rounding_scaling = 119 [default = 600];
inline bool SatParameters::_internal_has_max_integer_rounding_scaling() const {
  bool value = (_has_bits_[3] & 0x00008000u) != 0;
  return value;
}
inline bool SatParameters::has_max_integer_rounding_scaling() const {
  return _internal_has_max_integer_rounding_scaling();
}
inline void SatParameters::clear_max_integer_rounding_scaling() {
  max_integer_rounding_scaling_ = 600;
  _has_bits_[3] &= ~0x00008000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_integer_rounding_scaling() const {
  return max_integer_rounding_scaling_;
}
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 _internal_max_integer_rounding_scaling();
}
inline void SatParameters::_internal_set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00008000u;
  max_integer_rounding_scaling_ = value;
}
inline void SatParameters::set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_add_lp_constraints_lazily() const {
  bool value = (_has_bits_[3] & 0x00000080u) != 0;
  return value;
}
inline bool SatParameters::has_add_lp_constraints_lazily() const {
  return _internal_has_add_lp_constraints_lazily();
}
inline void SatParameters::clear_add_lp_constraints_lazily() {
  add_lp_constraints_lazily_ = true;
  _has_bits_[3] &= ~0x00000080u;
}
inline bool SatParameters::_internal_add_lp_constraints_lazily() const {
  return add_lp_constraints_lazily_;
}
inline bool SatParameters::add_lp_constraints_lazily() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_lp_constraints_lazily)
  return _internal_add_lp_constraints_lazily();
}
inline void SatParameters::_internal_set_add_lp_constraints_lazily(bool value) {
  _has_bits_[3] |= 0x00000080u;
  add_lp_constraints_lazily_ = value;
}
inline void SatParameters::set_add_lp_constraints_lazily(bool value) {
  _internal_set_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.05];
inline bool SatParameters::_internal_has_min_orthogonality_for_lp_constraints() const {
  bool value = (_has_bits_[3] & 0x00000040u) != 0;
  return value;
}
inline bool SatParameters::has_min_orthogonality_for_lp_constraints() const {
  return _internal_has_min_orthogonality_for_lp_constraints();
}
inline void SatParameters::clear_min_orthogonality_for_lp_constraints() {
  min_orthogonality_for_lp_constraints_ = 0.05;
  _has_bits_[3] &= ~0x00000040u;
}
inline double SatParameters::_internal_min_orthogonality_for_lp_constraints() const {
  return min_orthogonality_for_lp_constraints_;
}
inline double SatParameters::min_orthogonality_for_lp_constraints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
  return _internal_min_orthogonality_for_lp_constraints();
}
inline void SatParameters::_internal_set_min_orthogonality_for_lp_constraints(double value) {
  _has_bits_[3] |= 0x00000040u;
  min_orthogonality_for_lp_constraints_ = value;
}
inline void SatParameters::set_min_orthogonality_for_lp_constraints(double value) {
  _internal_set_min_orthogonality_for_lp_constraints(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
}

// optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
inline bool SatParameters::_internal_has_max_cut_rounds_at_level_zero() const {
  bool value = (_has_bits_[4] & 0x00000800u) != 0;
  return value;
}
inline bool SatParameters::has_max_cut_rounds_at_level_zero() const {
  return _internal_has_max_cut_rounds_at_level_zero();
}
inline void SatParameters::clear_max_cut_rounds_at_level_zero() {
  max_cut_rounds_at_level_zero_ = 1;
  _has_bits_[4] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_cut_rounds_at_level_zero() const {
  return max_cut_rounds_at_level_zero_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_cut_rounds_at_level_zero() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_cut_rounds_at_level_zero)
  return _internal_max_cut_rounds_at_level_zero();
}
inline void SatParameters::_internal_set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00000800u;
  max_cut_rounds_at_level_zero_ = value;
}
inline void SatParameters::set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_max_cut_rounds_at_level_zero(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_cut_rounds_at_level_zero)
}

// optional int32 max_consecutive_inactive_count = 121 [default = 100];
inline bool SatParameters::_internal_has_max_consecutive_inactive_count() const {
  bool value = (_has_bits_[3] & 0x00100000u) != 0;
  return value;
}
inline bool SatParameters::has_max_consecutive_inactive_count() const {
  return _internal_has_max_consecutive_inactive_count();
}
inline void SatParameters::clear_max_consecutive_inactive_count() {
  max_consecutive_inactive_count_ = 100;
  _has_bits_[3] &= ~0x00100000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_consecutive_inactive_count() const {
  return max_consecutive_inactive_count_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_consecutive_inactive_count() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_consecutive_inactive_count)
  return _internal_max_consecutive_inactive_count();
}
inline void SatParameters::_internal_set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00100000u;
  max_consecutive_inactive_count_ = value;
}
inline void SatParameters::set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_max_consecutive_inactive_count(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_consecutive_inactive_count)
}

// optional double cut_max_active_count_value = 155 [default = 10000000000];
inline bool SatParameters::_internal_has_cut_max_active_count_value() const {
  bool value = (_has_bits_[4] & 0x00000400u) != 0;
  return value;
}
inline bool SatParameters::has_cut_max_active_count_value() const {
  return _internal_has_cut_max_active_count_value();
}
inline void SatParameters::clear_cut_max_active_count_value() {
  cut_max_active_count_value_ = 10000000000;
  _has_bits_[4] &= ~0x00000400u;
}
inline double SatParameters::_internal_cut_max_active_count_value() const {
  return cut_max_active_count_value_;
}
inline double SatParameters::cut_max_active_count_value() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_max_active_count_value)
  return _internal_cut_max_active_count_value();
}
inline void SatParameters::_internal_set_cut_max_active_count_value(double value) {
  _has_bits_[4] |= 0x00000400u;
  cut_max_active_count_value_ = value;
}
inline void SatParameters::set_cut_max_active_count_value(double value) {
  _internal_set_cut_max_active_count_value(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_max_active_count_value)
}

// optional double cut_active_count_decay = 156 [default = 0.8];
inline bool SatParameters::_internal_has_cut_active_count_decay() const {
  bool value = (_has_bits_[4] & 0x00002000u) != 0;
  return value;
}
inline bool SatParameters::has_cut_active_count_decay() const {
  return _internal_has_cut_active_count_decay();
}
inline void SatParameters::clear_cut_active_count_decay() {
  cut_active_count_decay_ = 0.8;
  _has_bits_[4] &= ~0x00002000u;
}
inline double SatParameters::_internal_cut_active_count_decay() const {
  return cut_active_count_decay_;
}
inline double SatParameters::cut_active_count_decay() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_active_count_decay)
  return _internal_cut_active_count_decay();
}
inline void SatParameters::_internal_set_cut_active_count_decay(double value) {
  _has_bits_[4] |= 0x00002000u;
  cut_active_count_decay_ = value;
}
inline void SatParameters::set_cut_active_count_decay(double value) {
  _internal_set_cut_active_count_decay(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_active_count_decay)
}

// optional int32 cut_cleanup_target = 157 [default = 1000];
inline bool SatParameters::_internal_has_cut_cleanup_target() const {
  bool value = (_has_bits_[4] & 0x00001000u) != 0;
  return value;
}
inline bool SatParameters::has_cut_cleanup_target() const {
  return _internal_has_cut_cleanup_target();
}
inline void SatParameters::clear_cut_cleanup_target() {
  cut_cleanup_target_ = 1000;
  _has_bits_[4] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cut_cleanup_target() const {
  return cut_cleanup_target_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cut_cleanup_target() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_cleanup_target)
  return _internal_cut_cleanup_target();
}
inline void SatParameters::_internal_set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00001000u;
  cut_cleanup_target_ = value;
}
inline void SatParameters::set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_cut_cleanup_target(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_cleanup_target)
}

// optional int32 new_constraints_batch_size = 122 [default = 50];
inline bool SatParameters::_internal_has_new_constraints_batch_size() const {
  bool value = (_has_bits_[3] & 0x00200000u) != 0;
  return value;
}
inline bool SatParameters::has_new_constraints_batch_size() const {
  return _internal_has_new_constraints_batch_size();
}
inline void SatParameters::clear_new_constraints_batch_size() {
  new_constraints_batch_size_ = 50;
  _has_bits_[3] &= ~0x00200000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_new_constraints_batch_size() const {
  return new_constraints_batch_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::new_constraints_batch_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.new_constraints_batch_size)
  return _internal_new_constraints_batch_size();
}
inline void SatParameters::_internal_set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00200000u;
  new_constraints_batch_size_ = value;
}
inline void SatParameters::set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_new_constraints_batch_size(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.new_constraints_batch_size)
}

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

// optional int32 hint_conflict_limit = 153 [default = 10];
inline bool SatParameters::_internal_has_hint_conflict_limit() const {
  bool value = (_has_bits_[4] & 0x00000200u) != 0;
  return value;
}
inline bool SatParameters::has_hint_conflict_limit() const {
  return _internal_has_hint_conflict_limit();
}
inline void SatParameters::clear_hint_conflict_limit() {
  hint_conflict_limit_ = 10;
  _has_bits_[4] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_hint_conflict_limit() const {
  return hint_conflict_limit_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::hint_conflict_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.hint_conflict_limit)
  return _internal_hint_conflict_limit();
}
inline void SatParameters::_internal_set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00000200u;
  hint_conflict_limit_ = value;
}
inline void SatParameters::set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_hint_conflict_limit(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.hint_conflict_limit)
}

// optional bool exploit_integer_lp_solution = 94 [default = true];
inline bool SatParameters::_internal_has_exploit_integer_lp_solution() const {
  bool value = (_has_bits_[3] & 0x00000100u) != 0;
  return value;
}
inline bool SatParameters::has_exploit_integer_lp_solution() const {
  return _internal_has_exploit_integer_lp_solution();
}
inline void SatParameters::clear_exploit_integer_lp_solution() {
  exploit_integer_lp_solution_ = true;
  _has_bits_[3] &= ~0x00000100u;
}
inline bool SatParameters::_internal_exploit_integer_lp_solution() const {
  return exploit_integer_lp_solution_;
}
inline bool SatParameters::exploit_integer_lp_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_integer_lp_solution)
  return _internal_exploit_integer_lp_solution();
}
inline void SatParameters::_internal_set_exploit_integer_lp_solution(bool value) {
  _has_bits_[3] |= 0x00000100u;
  exploit_integer_lp_solution_ = value;
}
inline void SatParameters::set_exploit_integer_lp_solution(bool value) {
  _internal_set_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::_internal_has_exploit_all_lp_solution() const {
  bool value = (_has_bits_[3] & 0x00000200u) != 0;
  return value;
}
inline bool SatParameters::has_exploit_all_lp_solution() const {
  return _internal_has_exploit_all_lp_solution();
}
inline void SatParameters::clear_exploit_all_lp_solution() {
  exploit_all_lp_solution_ = true;
  _has_bits_[3] &= ~0x00000200u;
}
inline bool SatParameters::_internal_exploit_all_lp_solution() const {
  return exploit_all_lp_solution_;
}
inline bool SatParameters::exploit_all_lp_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_all_lp_solution)
  return _internal_exploit_all_lp_solution();
}
inline void SatParameters::_internal_set_exploit_all_lp_solution(bool value) {
  _has_bits_[3] |= 0x00000200u;
  exploit_all_lp_solution_ = value;
}
inline void SatParameters::set_exploit_all_lp_solution(bool value) {
  _internal_set_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::_internal_has_exploit_best_solution() const {
  bool value = (_has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool SatParameters::has_exploit_best_solution() const {
  return _internal_has_exploit_best_solution();
}
inline void SatParameters::clear_exploit_best_solution() {
  exploit_best_solution_ = false;
  _has_bits_[0] &= ~0x20000000u;
}
inline bool SatParameters::_internal_exploit_best_solution() const {
  return exploit_best_solution_;
}
inline bool SatParameters::exploit_best_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_best_solution)
  return _internal_exploit_best_solution();
}
inline void SatParameters::_internal_set_exploit_best_solution(bool value) {
  _has_bits_[0] |= 0x20000000u;
  exploit_best_solution_ = value;
}
inline void SatParameters::set_exploit_best_solution(bool value) {
  _internal_set_exploit_best_solution(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_best_solution)
}

// optional bool exploit_relaxation_solution = 161 [default = false];
inline bool SatParameters::_internal_has_exploit_relaxation_solution() const {
  bool value = (_has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool SatParameters::has_exploit_relaxation_solution() const {
  return _internal_has_exploit_relaxation_solution();
}
inline void SatParameters::clear_exploit_relaxation_solution() {
  exploit_relaxation_solution_ = false;
  _has_bits_[0] &= ~0x40000000u;
}
inline bool SatParameters::_internal_exploit_relaxation_solution() const {
  return exploit_relaxation_solution_;
}
inline bool SatParameters::exploit_relaxation_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_relaxation_solution)
  return _internal_exploit_relaxation_solution();
}
inline void SatParameters::_internal_set_exploit_relaxation_solution(bool value) {
  _has_bits_[0] |= 0x40000000u;
  exploit_relaxation_solution_ = value;
}
inline void SatParameters::set_exploit_relaxation_solution(bool value) {
  _internal_set_exploit_relaxation_solution(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_relaxation_solution)
}

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

// optional int64 probing_period_at_root = 142 [default = 0];
inline bool SatParameters::_internal_has_probing_period_at_root() const {
  bool value = (_has_bits_[1] & 0x00000400u) != 0;
  return value;
}
inline bool SatParameters::has_probing_period_at_root() const {
  return _internal_has_probing_period_at_root();
}
inline void SatParameters::clear_probing_period_at_root() {
  probing_period_at_root_ = PROTOBUF_LONGLONG(0);
  _has_bits_[1] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_probing_period_at_root() const {
  return probing_period_at_root_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::probing_period_at_root() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.probing_period_at_root)
  return _internal_probing_period_at_root();
}
inline void SatParameters::_internal_set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[1] |= 0x00000400u;
  probing_period_at_root_ = value;
}
inline void SatParameters::set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_probing_period_at_root(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.probing_period_at_root)
}

// optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
inline bool SatParameters::_internal_has_pseudo_cost_reliability_threshold() const {
  bool value = (_has_bits_[3] & 0x00400000u) != 0;
  return value;
}
inline bool SatParameters::has_pseudo_cost_reliability_threshold() const {
  return _internal_has_pseudo_cost_reliability_threshold();
}
inline void SatParameters::clear_pseudo_cost_reliability_threshold() {
  pseudo_cost_reliability_threshold_ = PROTOBUF_LONGLONG(100);
  _has_bits_[3] &= ~0x00400000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_pseudo_cost_reliability_threshold() const {
  return pseudo_cost_reliability_threshold_;
}
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 _internal_pseudo_cost_reliability_threshold();
}
inline void SatParameters::_internal_set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[3] |= 0x00400000u;
  pseudo_cost_reliability_threshold_ = value;
}
inline void SatParameters::set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_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::_internal_has_optimize_with_core() const {
  bool value = (_has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool SatParameters::has_optimize_with_core() const {
  return _internal_has_optimize_with_core();
}
inline void SatParameters::clear_optimize_with_core() {
  optimize_with_core_ = false;
  _has_bits_[0] &= ~0x80000000u;
}
inline bool SatParameters::_internal_optimize_with_core() const {
  return optimize_with_core_;
}
inline bool SatParameters::optimize_with_core() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_core)
  return _internal_optimize_with_core();
}
inline void SatParameters::_internal_set_optimize_with_core(bool value) {
  _has_bits_[0] |= 0x80000000u;
  optimize_with_core_ = value;
}
inline void SatParameters::set_optimize_with_core(bool value) {
  _internal_set_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::_internal_has_binary_search_num_conflicts() const {
  bool value = (_has_bits_[2] & 0x40000000u) != 0;
  return value;
}
inline bool SatParameters::has_binary_search_num_conflicts() const {
  return _internal_has_binary_search_num_conflicts();
}
inline void SatParameters::clear_binary_search_num_conflicts() {
  binary_search_num_conflicts_ = -1;
  _has_bits_[2] &= ~0x40000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_binary_search_num_conflicts() const {
  return binary_search_num_conflicts_;
}
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 _internal_binary_search_num_conflicts();
}
inline void SatParameters::_internal_set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x40000000u;
  binary_search_num_conflicts_ = value;
}
inline void SatParameters::set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_optimize_with_max_hs() const {
  bool value = (_has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool SatParameters::has_optimize_with_max_hs() const {
  return _internal_has_optimize_with_max_hs();
}
inline void SatParameters::clear_optimize_with_max_hs() {
  optimize_with_max_hs_ = false;
  _has_bits_[0] &= ~0x00080000u;
}
inline bool SatParameters::_internal_optimize_with_max_hs() const {
  return optimize_with_max_hs_;
}
inline bool SatParameters::optimize_with_max_hs() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_max_hs)
  return _internal_optimize_with_max_hs();
}
inline void SatParameters::_internal_set_optimize_with_max_hs(bool value) {
  _has_bits_[0] |= 0x00080000u;
  optimize_with_max_hs_ = value;
}
inline void SatParameters::set_optimize_with_max_hs(bool value) {
  _internal_set_optimize_with_max_hs(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_max_hs)
}

// optional bool enumerate_all_solutions = 87 [default = false];
inline bool SatParameters::_internal_has_enumerate_all_solutions() const {
  bool value = (_has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool SatParameters::has_enumerate_all_solutions() const {
  return _internal_has_enumerate_all_solutions();
}
inline void SatParameters::clear_enumerate_all_solutions() {
  enumerate_all_solutions_ = false;
  _has_bits_[0] &= ~0x00100000u;
}
inline bool SatParameters::_internal_enumerate_all_solutions() const {
  return enumerate_all_solutions_;
}
inline bool SatParameters::enumerate_all_solutions() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.enumerate_all_solutions)
  return _internal_enumerate_all_solutions();
}
inline void SatParameters::_internal_set_enumerate_all_solutions(bool value) {
  _has_bits_[0] |= 0x00100000u;
  enumerate_all_solutions_ = value;
}
inline void SatParameters::set_enumerate_all_solutions(bool value) {
  _internal_set_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::_internal_has_fill_tightened_domains_in_response() const {
  bool value = (_has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool SatParameters::has_fill_tightened_domains_in_response() const {
  return _internal_has_fill_tightened_domains_in_response();
}
inline void SatParameters::clear_fill_tightened_domains_in_response() {
  fill_tightened_domains_in_response_ = false;
  _has_bits_[0] &= ~0x00200000u;
}
inline bool SatParameters::_internal_fill_tightened_domains_in_response() const {
  return fill_tightened_domains_in_response_;
}
inline bool SatParameters::fill_tightened_domains_in_response() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fill_tightened_domains_in_response)
  return _internal_fill_tightened_domains_in_response();
}
inline void SatParameters::_internal_set_fill_tightened_domains_in_response(bool value) {
  _has_bits_[0] |= 0x00200000u;
  fill_tightened_domains_in_response_ = value;
}
inline void SatParameters::set_fill_tightened_domains_in_response(bool value) {
  _internal_set_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::_internal_has_instantiate_all_variables() const {
  bool value = (_has_bits_[3] & 0x00000002u) != 0;
  return value;
}
inline bool SatParameters::has_instantiate_all_variables() const {
  return _internal_has_instantiate_all_variables();
}
inline void SatParameters::clear_instantiate_all_variables() {
  instantiate_all_variables_ = true;
  _has_bits_[3] &= ~0x00000002u;
}
inline bool SatParameters::_internal_instantiate_all_variables() const {
  return instantiate_all_variables_;
}
inline bool SatParameters::instantiate_all_variables() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.instantiate_all_variables)
  return _internal_instantiate_all_variables();
}
inline void SatParameters::_internal_set_instantiate_all_variables(bool value) {
  _has_bits_[3] |= 0x00000002u;
  instantiate_all_variables_ = value;
}
inline void SatParameters::set_instantiate_all_variables(bool value) {
  _internal_set_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::_internal_has_auto_detect_greater_than_at_least_one_of() const {
  bool value = (_has_bits_[3] & 0x00000004u) != 0;
  return value;
}
inline bool SatParameters::has_auto_detect_greater_than_at_least_one_of() const {
  return _internal_has_auto_detect_greater_than_at_least_one_of();
}
inline void SatParameters::clear_auto_detect_greater_than_at_least_one_of() {
  auto_detect_greater_than_at_least_one_of_ = true;
  _has_bits_[3] &= ~0x00000004u;
}
inline bool SatParameters::_internal_auto_detect_greater_than_at_least_one_of() const {
  return auto_detect_greater_than_at_least_one_of_;
}
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 _internal_auto_detect_greater_than_at_least_one_of();
}
inline void SatParameters::_internal_set_auto_detect_greater_than_at_least_one_of(bool value) {
  _has_bits_[3] |= 0x00000004u;
  auto_detect_greater_than_at_least_one_of_ = value;
}
inline void SatParameters::set_auto_detect_greater_than_at_least_one_of(bool value) {
  _internal_set_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::_internal_has_stop_after_first_solution() const {
  bool value = (_has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool SatParameters::has_stop_after_first_solution() const {
  return _internal_has_stop_after_first_solution();
}
inline void SatParameters::clear_stop_after_first_solution() {
  stop_after_first_solution_ = false;
  _has_bits_[0] &= ~0x00400000u;
}
inline bool SatParameters::_internal_stop_after_first_solution() const {
  return stop_after_first_solution_;
}
inline bool SatParameters::stop_after_first_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.stop_after_first_solution)
  return _internal_stop_after_first_solution();
}
inline void SatParameters::_internal_set_stop_after_first_solution(bool value) {
  _has_bits_[0] |= 0x00400000u;
  stop_after_first_solution_ = value;
}
inline void SatParameters::set_stop_after_first_solution(bool value) {
  _internal_set_stop_after_first_solution(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_first_solution)
}

// optional bool stop_after_presolve = 149 [default = false];
inline bool SatParameters::_internal_has_stop_after_presolve() const {
  bool value = (_has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline bool SatParameters::has_stop_after_presolve() const {
  return _internal_has_stop_after_presolve();
}
inline void SatParameters::clear_stop_after_presolve() {
  stop_after_presolve_ = false;
  _has_bits_[1] &= ~0x00000010u;
}
inline bool SatParameters::_internal_stop_after_presolve() const {
  return stop_after_presolve_;
}
inline bool SatParameters::stop_after_presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.stop_after_presolve)
  return _internal_stop_after_presolve();
}
inline void SatParameters::_internal_set_stop_after_presolve(bool value) {
  _has_bits_[1] |= 0x00000010u;
  stop_after_presolve_ = value;
}
inline void SatParameters::set_stop_after_presolve(bool value) {
  _internal_set_stop_after_presolve(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_presolve)
}

// optional int32 num_search_workers = 100 [default = 1];
inline bool SatParameters::_internal_has_num_search_workers() const {
  bool value = (_has_bits_[2] & 0x80000000u) != 0;
  return value;
}
inline bool SatParameters::has_num_search_workers() const {
  return _internal_has_num_search_workers();
}
inline void SatParameters::clear_num_search_workers() {
  num_search_workers_ = 1;
  _has_bits_[2] &= ~0x80000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_num_search_workers() const {
  return num_search_workers_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::num_search_workers() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_search_workers)
  return _internal_num_search_workers();
}
inline void SatParameters::_internal_set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x80000000u;
  num_search_workers_ = value;
}
inline void SatParameters::set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_interleave_search() const {
  bool value = (_has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline bool SatParameters::has_interleave_search() const {
  return _internal_has_interleave_search();
}
inline void SatParameters::clear_interleave_search() {
  interleave_search_ = false;
  _has_bits_[1] &= ~0x00000020u;
}
inline bool SatParameters::_internal_interleave_search() const {
  return interleave_search_;
}
inline bool SatParameters::interleave_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.interleave_search)
  return _internal_interleave_search();
}
inline void SatParameters::_internal_set_interleave_search(bool value) {
  _has_bits_[1] |= 0x00000020u;
  interleave_search_ = value;
}
inline void SatParameters::set_interleave_search(bool value) {
  _internal_set_interleave_search(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_search)
}

// optional int32 interleave_batch_size = 134 [default = 1];
inline bool SatParameters::_internal_has_interleave_batch_size() const {
  bool value = (_has_bits_[4] & 0x00000001u) != 0;
  return value;
}
inline bool SatParameters::has_interleave_batch_size() const {
  return _internal_has_interleave_batch_size();
}
inline void SatParameters::clear_interleave_batch_size() {
  interleave_batch_size_ = 1;
  _has_bits_[4] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_interleave_batch_size() const {
  return interleave_batch_size_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::interleave_batch_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.interleave_batch_size)
  return _internal_interleave_batch_size();
}
inline void SatParameters::_internal_set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00000001u;
  interleave_batch_size_ = value;
}
inline void SatParameters::set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_interleave_batch_size(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_batch_size)
}

// optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
inline bool SatParameters::_internal_has_reduce_memory_usage_in_interleave_mode() const {
  bool value = (_has_bits_[1] & 0x00000040u) != 0;
  return value;
}
inline bool SatParameters::has_reduce_memory_usage_in_interleave_mode() const {
  return _internal_has_reduce_memory_usage_in_interleave_mode();
}
inline void SatParameters::clear_reduce_memory_usage_in_interleave_mode() {
  reduce_memory_usage_in_interleave_mode_ = false;
  _has_bits_[1] &= ~0x00000040u;
}
inline bool SatParameters::_internal_reduce_memory_usage_in_interleave_mode() const {
  return reduce_memory_usage_in_interleave_mode_;
}
inline bool SatParameters::reduce_memory_usage_in_interleave_mode() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.reduce_memory_usage_in_interleave_mode)
  return _internal_reduce_memory_usage_in_interleave_mode();
}
inline void SatParameters::_internal_set_reduce_memory_usage_in_interleave_mode(bool value) {
  _has_bits_[1] |= 0x00000040u;
  reduce_memory_usage_in_interleave_mode_ = value;
}
inline void SatParameters::set_reduce_memory_usage_in_interleave_mode(bool value) {
  _internal_set_reduce_memory_usage_in_interleave_mode(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.reduce_memory_usage_in_interleave_mode)
}

// optional bool share_objective_bounds = 113 [default = true];
inline bool SatParameters::_internal_has_share_objective_bounds() const {
  bool value = (_has_bits_[3] & 0x00000008u) != 0;
  return value;
}
inline bool SatParameters::has_share_objective_bounds() const {
  return _internal_has_share_objective_bounds();
}
inline void SatParameters::clear_share_objective_bounds() {
  share_objective_bounds_ = true;
  _has_bits_[3] &= ~0x00000008u;
}
inline bool SatParameters::_internal_share_objective_bounds() const {
  return share_objective_bounds_;
}
inline bool SatParameters::share_objective_bounds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_objective_bounds)
  return _internal_share_objective_bounds();
}
inline void SatParameters::_internal_set_share_objective_bounds(bool value) {
  _has_bits_[3] |= 0x00000008u;
  share_objective_bounds_ = value;
}
inline void SatParameters::set_share_objective_bounds(bool value) {
  _internal_set_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::_internal_has_share_level_zero_bounds() const {
  bool value = (_has_bits_[3] & 0x00000010u) != 0;
  return value;
}
inline bool SatParameters::has_share_level_zero_bounds() const {
  return _internal_has_share_level_zero_bounds();
}
inline void SatParameters::clear_share_level_zero_bounds() {
  share_level_zero_bounds_ = true;
  _has_bits_[3] &= ~0x00000010u;
}
inline bool SatParameters::_internal_share_level_zero_bounds() const {
  return share_level_zero_bounds_;
}
inline bool SatParameters::share_level_zero_bounds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_level_zero_bounds)
  return _internal_share_level_zero_bounds();
}
inline void SatParameters::_internal_set_share_level_zero_bounds(bool value) {
  _has_bits_[3] |= 0x00000010u;
  share_level_zero_bounds_ = value;
}
inline void SatParameters::set_share_level_zero_bounds(bool value) {
  _internal_set_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::_internal_has_use_lns_only() const {
  bool value = (_has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline bool SatParameters::has_use_lns_only() const {
  return _internal_has_use_lns_only();
}
inline void SatParameters::clear_use_lns_only() {
  use_lns_only_ = false;
  _has_bits_[1] &= ~0x00000080u;
}
inline bool SatParameters::_internal_use_lns_only() const {
  return use_lns_only_;
}
inline bool SatParameters::use_lns_only() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_lns_only)
  return _internal_use_lns_only();
}
inline void SatParameters::_internal_set_use_lns_only(bool value) {
  _has_bits_[1] |= 0x00000080u;
  use_lns_only_ = value;
}
inline void SatParameters::set_use_lns_only(bool value) {
  _internal_set_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::_internal_has_lns_focus_on_decision_variables() const {
  bool value = (_has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool SatParameters::has_lns_focus_on_decision_variables() const {
  return _internal_has_lns_focus_on_decision_variables();
}
inline void SatParameters::clear_lns_focus_on_decision_variables() {
  lns_focus_on_decision_variables_ = false;
  _has_bits_[1] &= ~0x00000001u;
}
inline bool SatParameters::_internal_lns_focus_on_decision_variables() const {
  return lns_focus_on_decision_variables_;
}
inline bool SatParameters::lns_focus_on_decision_variables() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lns_focus_on_decision_variables)
  return _internal_lns_focus_on_decision_variables();
}
inline void SatParameters::_internal_set_lns_focus_on_decision_variables(bool value) {
  _has_bits_[1] |= 0x00000001u;
  lns_focus_on_decision_variables_ = value;
}
inline void SatParameters::set_lns_focus_on_decision_variables(bool value) {
  _internal_set_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::_internal_has_use_rins_lns() const {
  bool value = (_has_bits_[3] & 0x08000000u) != 0;
  return value;
}
inline bool SatParameters::has_use_rins_lns() const {
  return _internal_has_use_rins_lns();
}
inline void SatParameters::clear_use_rins_lns() {
  use_rins_lns_ = true;
  _has_bits_[3] &= ~0x08000000u;
}
inline bool SatParameters::_internal_use_rins_lns() const {
  return use_rins_lns_;
}
inline bool SatParameters::use_rins_lns() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_rins_lns)
  return _internal_use_rins_lns();
}
inline void SatParameters::_internal_set_use_rins_lns(bool value) {
  _has_bits_[3] |= 0x08000000u;
  use_rins_lns_ = value;
}
inline void SatParameters::set_use_rins_lns(bool value) {
  _internal_set_use_rins_lns(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_rins_lns)
}

// optional bool use_feasibility_pump = 164 [default = true];
inline bool SatParameters::_internal_has_use_feasibility_pump() const {
  bool value = (_has_bits_[3] & 0x10000000u) != 0;
  return value;
}
inline bool SatParameters::has_use_feasibility_pump() const {
  return _internal_has_use_feasibility_pump();
}
inline void SatParameters::clear_use_feasibility_pump() {
  use_feasibility_pump_ = true;
  _has_bits_[3] &= ~0x10000000u;
}
inline bool SatParameters::_internal_use_feasibility_pump() const {
  return use_feasibility_pump_;
}
inline bool SatParameters::use_feasibility_pump() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_feasibility_pump)
  return _internal_use_feasibility_pump();
}
inline void SatParameters::_internal_set_use_feasibility_pump(bool value) {
  _has_bits_[3] |= 0x10000000u;
  use_feasibility_pump_ = value;
}
inline void SatParameters::set_use_feasibility_pump(bool value) {
  _internal_set_use_feasibility_pump(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_feasibility_pump)
}

// optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
inline bool SatParameters::_internal_has_fp_rounding() const {
  bool value = (_has_bits_[1] & 0x00004000u) != 0;
  return value;
}
inline bool SatParameters::has_fp_rounding() const {
  return _internal_has_fp_rounding();
}
inline void SatParameters::clear_fp_rounding() {
  fp_rounding_ = 2;
  _has_bits_[1] &= ~0x00004000u;
}
inline ::operations_research::sat::SatParameters_FPRoundingMethod SatParameters::_internal_fp_rounding() const {
  return static_cast< ::operations_research::sat::SatParameters_FPRoundingMethod >(fp_rounding_);
}
inline ::operations_research::sat::SatParameters_FPRoundingMethod SatParameters::fp_rounding() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fp_rounding)
  return _internal_fp_rounding();
}
inline void SatParameters::_internal_set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value) {
  assert(::operations_research::sat::SatParameters_FPRoundingMethod_IsValid(value));
  _has_bits_[1] |= 0x00004000u;
  fp_rounding_ = value;
}
inline void SatParameters::set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value) {
  _internal_set_fp_rounding(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fp_rounding)
}

// optional bool use_relaxation_lns = 150 [default = false];
inline bool SatParameters::_internal_has_use_relaxation_lns() const {
  bool value = (_has_bits_[1] & 0x00000002u) != 0;
  return value;
}
inline bool SatParameters::has_use_relaxation_lns() const {
  return _internal_has_use_relaxation_lns();
}
inline void SatParameters::clear_use_relaxation_lns() {
  use_relaxation_lns_ = false;
  _has_bits_[1] &= ~0x00000002u;
}
inline bool SatParameters::_internal_use_relaxation_lns() const {
  return use_relaxation_lns_;
}
inline bool SatParameters::use_relaxation_lns() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_relaxation_lns)
  return _internal_use_relaxation_lns();
}
inline void SatParameters::_internal_set_use_relaxation_lns(bool value) {
  _has_bits_[1] |= 0x00000002u;
  use_relaxation_lns_ = value;
}
inline void SatParameters::set_use_relaxation_lns(bool value) {
  _internal_set_use_relaxation_lns(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_relaxation_lns)
}

// optional bool diversify_lns_params = 137 [default = false];
inline bool SatParameters::_internal_has_diversify_lns_params() const {
  bool value = (_has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool SatParameters::has_diversify_lns_params() const {
  return _internal_has_diversify_lns_params();
}
inline void SatParameters::clear_diversify_lns_params() {
  diversify_lns_params_ = false;
  _has_bits_[1] &= ~0x00000004u;
}
inline bool SatParameters::_internal_diversify_lns_params() const {
  return diversify_lns_params_;
}
inline bool SatParameters::diversify_lns_params() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.diversify_lns_params)
  return _internal_diversify_lns_params();
}
inline void SatParameters::_internal_set_diversify_lns_params(bool value) {
  _has_bits_[1] |= 0x00000004u;
  diversify_lns_params_ = value;
}
inline void SatParameters::set_diversify_lns_params(bool value) {
  _internal_set_diversify_lns_params(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.diversify_lns_params)
}

// optional bool randomize_search = 103 [default = false];
inline bool SatParameters::_internal_has_randomize_search() const {
  bool value = (_has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline bool SatParameters::has_randomize_search() const {
  return _internal_has_randomize_search();
}
inline void SatParameters::clear_randomize_search() {
  randomize_search_ = false;
  _has_bits_[1] &= ~0x00000008u;
}
inline bool SatParameters::_internal_randomize_search() const {
  return randomize_search_;
}
inline bool SatParameters::randomize_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.randomize_search)
  return _internal_randomize_search();
}
inline void SatParameters::_internal_set_randomize_search(bool value) {
  _has_bits_[1] |= 0x00000008u;
  randomize_search_ = value;
}
inline void SatParameters::set_randomize_search(bool value) {
  _internal_set_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::_internal_has_search_randomization_tolerance() const {
  bool value = (_has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool SatParameters::has_search_randomization_tolerance() const {
  return _internal_has_search_randomization_tolerance();
}
inline void SatParameters::clear_search_randomization_tolerance() {
  search_randomization_tolerance_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x08000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_search_randomization_tolerance() const {
  return search_randomization_tolerance_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::search_randomization_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.search_randomization_tolerance)
  return _internal_search_randomization_tolerance();
}
inline void SatParameters::_internal_set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x08000000u;
  search_randomization_tolerance_ = value;
}
inline void SatParameters::set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_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::_internal_has_use_optional_variables() const {
  bool value = (_has_bits_[3] & 0x20000000u) != 0;
  return value;
}
inline bool SatParameters::has_use_optional_variables() const {
  return _internal_has_use_optional_variables();
}
inline void SatParameters::clear_use_optional_variables() {
  use_optional_variables_ = true;
  _has_bits_[3] &= ~0x20000000u;
}
inline bool SatParameters::_internal_use_optional_variables() const {
  return use_optional_variables_;
}
inline bool SatParameters::use_optional_variables() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_optional_variables)
  return _internal_use_optional_variables();
}
inline void SatParameters::_internal_set_use_optional_variables(bool value) {
  _has_bits_[3] |= 0x20000000u;
  use_optional_variables_ = value;
}
inline void SatParameters::set_use_optional_variables(bool value) {
  _internal_set_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::_internal_has_use_exact_lp_reason() const {
  bool value = (_has_bits_[3] & 0x40000000u) != 0;
  return value;
}
inline bool SatParameters::has_use_exact_lp_reason() const {
  return _internal_has_use_exact_lp_reason();
}
inline void SatParameters::clear_use_exact_lp_reason() {
  use_exact_lp_reason_ = true;
  _has_bits_[3] &= ~0x40000000u;
}
inline bool SatParameters::_internal_use_exact_lp_reason() const {
  return use_exact_lp_reason_;
}
inline bool SatParameters::use_exact_lp_reason() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_exact_lp_reason)
  return _internal_use_exact_lp_reason();
}
inline void SatParameters::_internal_set_use_exact_lp_reason(bool value) {
  _has_bits_[3] |= 0x40000000u;
  use_exact_lp_reason_ = value;
}
inline void SatParameters::set_use_exact_lp_reason(bool value) {
  _internal_set_use_exact_lp_reason(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_exact_lp_reason)
}

// optional bool use_branching_in_lp = 139 [default = false];
inline bool SatParameters::_internal_has_use_branching_in_lp() const {
  bool value = (_has_bits_[1] & 0x00000100u) != 0;
  return value;
}
inline bool SatParameters::has_use_branching_in_lp() const {
  return _internal_has_use_branching_in_lp();
}
inline void SatParameters::clear_use_branching_in_lp() {
  use_branching_in_lp_ = false;
  _has_bits_[1] &= ~0x00000100u;
}
inline bool SatParameters::_internal_use_branching_in_lp() const {
  return use_branching_in_lp_;
}
inline bool SatParameters::use_branching_in_lp() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_branching_in_lp)
  return _internal_use_branching_in_lp();
}
inline void SatParameters::_internal_set_use_branching_in_lp(bool value) {
  _has_bits_[1] |= 0x00000100u;
  use_branching_in_lp_ = value;
}
inline void SatParameters::set_use_branching_in_lp(bool value) {
  _internal_set_use_branching_in_lp(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_branching_in_lp)
}

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

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

// optional bool use_implied_bounds = 144 [default = true];
inline bool SatParameters::_internal_has_use_implied_bounds() const {
  bool value = (_has_bits_[4] & 0x00000080u) != 0;
  return value;
}
inline bool SatParameters::has_use_implied_bounds() const {
  return _internal_has_use_implied_bounds();
}
inline void SatParameters::clear_use_implied_bounds() {
  use_implied_bounds_ = true;
  _has_bits_[4] &= ~0x00000080u;
}
inline bool SatParameters::_internal_use_implied_bounds() const {
  return use_implied_bounds_;
}
inline bool SatParameters::use_implied_bounds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_implied_bounds)
  return _internal_use_implied_bounds();
}
inline void SatParameters::_internal_set_use_implied_bounds(bool value) {
  _has_bits_[4] |= 0x00000080u;
  use_implied_bounds_ = value;
}
inline void SatParameters::set_use_implied_bounds(bool value) {
  _internal_set_use_implied_bounds(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_implied_bounds)
}

// optional double mip_max_bound = 124 [default = 10000000];
inline bool SatParameters::_internal_has_mip_max_bound() const {
  bool value = (_has_bits_[3] & 0x00800000u) != 0;
  return value;
}
inline bool SatParameters::has_mip_max_bound() const {
  return _internal_has_mip_max_bound();
}
inline void SatParameters::clear_mip_max_bound() {
  mip_max_bound_ = 10000000;
  _has_bits_[3] &= ~0x00800000u;
}
inline double SatParameters::_internal_mip_max_bound() const {
  return mip_max_bound_;
}
inline double SatParameters::mip_max_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_max_bound)
  return _internal_mip_max_bound();
}
inline void SatParameters::_internal_set_mip_max_bound(double value) {
  _has_bits_[3] |= 0x00800000u;
  mip_max_bound_ = value;
}
inline void SatParameters::set_mip_max_bound(double value) {
  _internal_set_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::_internal_has_mip_var_scaling() const {
  bool value = (_has_bits_[3] & 0x01000000u) != 0;
  return value;
}
inline bool SatParameters::has_mip_var_scaling() const {
  return _internal_has_mip_var_scaling();
}
inline void SatParameters::clear_mip_var_scaling() {
  mip_var_scaling_ = 1;
  _has_bits_[3] &= ~0x01000000u;
}
inline double SatParameters::_internal_mip_var_scaling() const {
  return mip_var_scaling_;
}
inline double SatParameters::mip_var_scaling() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_var_scaling)
  return _internal_mip_var_scaling();
}
inline void SatParameters::_internal_set_mip_var_scaling(double value) {
  _has_bits_[3] |= 0x01000000u;
  mip_var_scaling_ = value;
}
inline void SatParameters::set_mip_var_scaling(double value) {
  _internal_set_mip_var_scaling(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_var_scaling)
}

// optional bool mip_automatically_scale_variables = 166 [default = true];
inline bool SatParameters::_internal_has_mip_automatically_scale_variables() const {
  bool value = (_has_bits_[4] & 0x00000100u) != 0;
  return value;
}
inline bool SatParameters::has_mip_automatically_scale_variables() const {
  return _internal_has_mip_automatically_scale_variables();
}
inline void SatParameters::clear_mip_automatically_scale_variables() {
  mip_automatically_scale_variables_ = true;
  _has_bits_[4] &= ~0x00000100u;
}
inline bool SatParameters::_internal_mip_automatically_scale_variables() const {
  return mip_automatically_scale_variables_;
}
inline bool SatParameters::mip_automatically_scale_variables() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_automatically_scale_variables)
  return _internal_mip_automatically_scale_variables();
}
inline void SatParameters::_internal_set_mip_automatically_scale_variables(bool value) {
  _has_bits_[4] |= 0x00000100u;
  mip_automatically_scale_variables_ = value;
}
inline void SatParameters::set_mip_automatically_scale_variables(bool value) {
  _internal_set_mip_automatically_scale_variables(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_automatically_scale_variables)
}

// optional double mip_wanted_precision = 126 [default = 1e-06];
inline bool SatParameters::_internal_has_mip_wanted_precision() const {
  bool value = (_has_bits_[3] & 0x02000000u) != 0;
  return value;
}
inline bool SatParameters::has_mip_wanted_precision() const {
  return _internal_has_mip_wanted_precision();
}
inline void SatParameters::clear_mip_wanted_precision() {
  mip_wanted_precision_ = 1e-06;
  _has_bits_[3] &= ~0x02000000u;
}
inline double SatParameters::_internal_mip_wanted_precision() const {
  return mip_wanted_precision_;
}
inline double SatParameters::mip_wanted_precision() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_wanted_precision)
  return _internal_mip_wanted_precision();
}
inline void SatParameters::_internal_set_mip_wanted_precision(double value) {
  _has_bits_[3] |= 0x02000000u;
  mip_wanted_precision_ = value;
}
inline void SatParameters::set_mip_wanted_precision(double value) {
  _internal_set_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::_internal_has_mip_max_activity_exponent() const {
  bool value = (_has_bits_[3] & 0x04000000u) != 0;
  return value;
}
inline bool SatParameters::has_mip_max_activity_exponent() const {
  return _internal_has_mip_max_activity_exponent();
}
inline void SatParameters::clear_mip_max_activity_exponent() {
  mip_max_activity_exponent_ = 53;
  _has_bits_[3] &= ~0x04000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_mip_max_activity_exponent() const {
  return mip_max_activity_exponent_;
}
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 _internal_mip_max_activity_exponent();
}
inline void SatParameters::_internal_set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x04000000u;
  mip_max_activity_exponent_ = value;
}
inline void SatParameters::set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_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::_internal_has_mip_check_precision() const {
  bool value = (_has_bits_[3] & 0x80000000u) != 0;
  return value;
}
inline bool SatParameters::has_mip_check_precision() const {
  return _internal_has_mip_check_precision();
}
inline void SatParameters::clear_mip_check_precision() {
  mip_check_precision_ = 0.0001;
  _has_bits_[3] &= ~0x80000000u;
}
inline double SatParameters::_internal_mip_check_precision() const {
  return mip_check_precision_;
}
inline double SatParameters::mip_check_precision() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_check_precision)
  return _internal_mip_check_precision();
}
inline void SatParameters::_internal_set_mip_check_precision(double value) {
  _has_bits_[3] |= 0x80000000u;
  mip_check_precision_ = value;
}
inline void SatParameters::set_mip_check_precision(double value) {
  _internal_set_mip_check_precision(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_check_precision)
}

#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();
}
template <> struct is_proto_enum< ::operations_research::sat::SatParameters_FPRoundingMethod> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_FPRoundingMethod>() {
  return ::operations_research::sat::SatParameters_FPRoundingMethod_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
