sat_parameters.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ortools/sat/sat_parameters.proto
 
#ifndef GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
 
#include <limits>
#include <string>
 
#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3019000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3019001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_ortools_2fsat_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::AuxiliaryParseTableField 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 uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto;
namespace operations_research {
namespace sat {
class SatParameters;
struct 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_FPRoundingMethod* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_FPRoundingMethod>(
    SatParameters_FPRoundingMethod_descriptor(), name, value);
}
// ===================================================================
 
class SatParameters final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.SatParameters) */ {
 public:
  inline SatParameters() : SatParameters(nullptr) {}
  ~SatParameters() override;
  explicit constexpr SatParameters(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
 
  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 (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  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 default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SatParameters& default_instance() {
    return *internal_default_instance();
  }
  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;
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() != nullptr &&
        GetOwningArena() == other->GetOwningArena()) {
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
    if (GetOwningArena() == other->GetOwningArena()) {
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SatParameters* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SatParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<SatParameters>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const SatParameters& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const SatParameters& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;
 
  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  uint8_t* _InternalSerialize(
      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }
 
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SatParameters* other);
 
  private:
  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,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:
 
  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
 
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
 
  // nested types ----------------------------------------------------
 
  typedef 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam 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(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      FPRoundingMethod* value) {
    return SatParameters_FPRoundingMethod_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  enum : int {
    kRestartAlgorithmsFieldNumber = 61,
    kDefaultRestartAlgorithmsFieldNumber = 70,
    kNameFieldNumber = 171,
    kLogPrefixFieldNumber = 185,
    kPreferredVariableOrderFieldNumber = 1,
    kClauseCleanupTargetFieldNumber = 13,
    kRandomBranchesRatioFieldNumber = 32,
    kRandomPolarityRatioFieldNumber = 45,
    kMaxSatAssumptionOrderFieldNumber = 51,
    kClauseCleanupProtectionFieldNumber = 58,
    kClauseCleanupOrderingFieldNumber = 60,
    kNumConflictsBeforeStrategyChangesFieldNumber = 68,
    kStrategyChangeIncreaseRatioFieldNumber = 69,
    kInitialVariablesActivityFieldNumber = 76,
    kSearchBranchingFieldNumber = 82,
    kUseErwaHeuristicFieldNumber = 75,
    kAlsoBumpVariablesInConflictReasonsFieldNumber = 77,
    kUseBlockingRestartFieldNumber = 64,
    kPermuteVariableRandomlyFieldNumber = 178,
    kNumSearchWorkersFieldNumber = 100,
    kMaxSatReverseAssumptionOrderFieldNumber = 52,
    kUseOverloadCheckerInCumulativeConstraintFieldNumber = 78,
    kUseTimetableEdgeFindingInCumulativeConstraintFieldNumber = 79,
    kUseCumulativeInNoOverlap2DFieldNumber = 200,
    kSearchRandomizationToleranceFieldNumber = 104,
    kUsePbResolutionFieldNumber = 43,
    kMinimizeReductionDuringPbResolutionFieldNumber = 48,
    kUseSatInprocessingFieldNumber = 163,
    kExpandAlldiffConstraintsFieldNumber = 170,
    kDiversifyLnsParamsFieldNumber = 137,
    kRandomizeSearchFieldNumber = 103,
    kUseBranchingInLpFieldNumber = 139,
    kUseCombinedNoOverlapFieldNumber = 133,
    kInterleaveSearchFieldNumber = 136,
    kReduceMemoryUsageInInterleaveModeFieldNumber = 141,
    kUseLnsOnlyFieldNumber = 101,
    kUseRelaxationLnsFieldNumber = 150,
    kOptimizeWithLbTreeSearchFieldNumber = 188,
    kOptimizeWithMaxHsFieldNumber = 85,
    kEnumerateAllSolutionsFieldNumber = 87,
    kKeepAllFeasibleSolutionsInPresolveFieldNumber = 173,
    kExploitBestSolutionFieldNumber = 130,
    kExploitRelaxationSolutionFieldNumber = 161,
    kUseProbingSearchFieldNumber = 176,
    kOptimizeWithCoreFieldNumber = 83,
    kFillTightenedDomainsInResponseFieldNumber = 132,
    kFillAdditionalSolutionsInResponseFieldNumber = 194,
    kStopAfterFirstSolutionFieldNumber = 98,
    kStopAfterPresolveFieldNumber = 149,
    kProbingPeriodAtRootFieldNumber = 142,
    kPermutePresolveConstraintOrderFieldNumber = 179,
    kUseAbslRandomFieldNumber = 180,
    kLogSearchProgressFieldNumber = 41,
    kLogToResponseFieldNumber = 187,
    kDebugMaxNumPresolveOperationsFieldNumber = 151,
    kRelativeGapLimitFieldNumber = 160,
    kOnlyAddCutsAtLevelZeroFieldNumber = 92,
    kAddObjectiveCutFieldNumber = 197,
    kRepairHintFieldNumber = 167,
    kFixVariablesToTheirHintedValueFieldNumber = 192,
    kPolishLpSolutionFieldNumber = 175,
    kDisableConstraintExpansionFieldNumber = 181,
    kPresolveExtractIntegerEnforcementFieldNumber = 174,
    kDebugPostsolveWithFullSolverFieldNumber = 162,
    kDebugCrashOnBadHintFieldNumber = 195,
    kCutLevelFieldNumber = 196,
    kInitialPolarityFieldNumber = 2,
    kMinimizationAlgorithmFieldNumber = 4,
    kVariableActivityDecayFieldNumber = 15,
    kMaxVariableActivityValueFieldNumber = 16,
    kClauseActivityDecayFieldNumber = 17,
    kClauseCleanupPeriodFieldNumber = 11,
    kGlucoseDecayIncrementPeriodFieldNumber = 24,
    kMaxClauseActivityValueFieldNumber = 18,
    kGlucoseMaxDecayFieldNumber = 22,
    kGlucoseDecayIncrementFieldNumber = 23,
    kRestartPeriodFieldNumber = 30,
    kRandomSeedFieldNumber = 31,
    kMaxTimeInSecondsFieldNumber = 36,
    kMaxNumberOfConflictsFieldNumber = 37,
    kMaxMemoryInMbFieldNumber = 40,
    kBinaryMinimizationAlgorithmFieldNumber = 34,
    kPbCleanupIncrementFieldNumber = 46,
    kPbCleanupRatioFieldNumber = 47,
    kMaxSatStratificationFieldNumber = 53,
    kPresolveBveThresholdFieldNumber = 54,
    kPresolveProbingDeterministicTimeLimitFieldNumber = 57,
    kPresolveBveClauseWeightFieldNumber = 55,
    kClauseCleanupLbdBoundFieldNumber = 59,
    kRestartDlAverageRatioFieldNumber = 63,
    kRestartRunningWindowSizeFieldNumber = 62,
    kBlockingRestartWindowSizeFieldNumber = 65,
    kBlockingRestartMultiplierFieldNumber = 66,
    kMaxDeterministicTimeFieldNumber = 67,
    kCpModelPresolveFieldNumber = 86,
    kCpModelUseSatPresolveFieldNumber = 93,
    kUseOptimizationHintsFieldNumber = 35,
    kMinimizeCoreFieldNumber = 50,
    kPresolveBvaThresholdFieldNumber = 73,
    kRestartLbdAverageRatioFieldNumber = 71,
    kUsePhaseSavingFieldNumber = 44,
    kSubsumptionDuringConflictAnalysisFieldNumber = 56,
    kTreatBinaryClausesSeparatelyFieldNumber = 33,
    kLogSubsolverStatisticsFieldNumber = 189,
    kFindMultipleCoresFieldNumber = 84,
    kCoverOptimizationFieldNumber = 89,
    kUsePrecedencesInDisjunctiveConstraintFieldNumber = 74,
    kUseDisjunctiveConstraintInCumulativeConstraintFieldNumber = 80,
    kLinearizationLevelFieldNumber = 90,
    kMaxNumCutsFieldNumber = 91,
    kMinimizeWithPropagationRestartPeriodFieldNumber = 96,
    kMinimizeWithPropagationNumDecisionsFieldNumber = 97,
    kLogToStdoutFieldNumber = 186,
    kCountAssumptionLevelsInLbdFieldNumber = 49,
    kPresolveBlockedClauseFieldNumber = 88,
    kPresolveUseBvaFieldNumber = 72,
    kBinarySearchNumConflictsFieldNumber = 99,
    kBooleanEncodingLevelFieldNumber = 107,
    kCpModelProbingLevelFieldNumber = 110,
    kExploitObjectiveFieldNumber = 131,
    kInstantiateAllVariablesFieldNumber = 106,
    kAutoDetectGreaterThanAtLeastOneOfFieldNumber = 95,
    kShareObjectiveBoundsFieldNumber = 113,
    kAddLinMaxCutsFieldNumber = 152,
    kAddLpConstraintsLazilyFieldNumber = 112,
    kExploitIntegerLpSolutionFieldNumber = 94,
    kExploitAllLpSolutionFieldNumber = 116,
    kMinOrthogonalityForLpConstraintsFieldNumber = 115,
    kMaxIntegerRoundingScalingFieldNumber = 119,
    kMaxConsecutiveInactiveCountFieldNumber = 121,
    kPseudoCostReliabilityThresholdFieldNumber = 123,
    kMipMaxBoundFieldNumber = 124,
    kNewConstraintsBatchSizeFieldNumber = 122,
    kMipMaxActivityExponentFieldNumber = 127,
    kMipVarScalingFieldNumber = 125,
    kMipWantedPrecisionFieldNumber = 126,
    kMipCheckPrecisionFieldNumber = 128,
    kShareLevelZeroBoundsFieldNumber = 114,
    kUseRinsLnsFieldNumber = 129,
    kUseFeasibilityPumpFieldNumber = 164,
    kUseOptionalVariablesFieldNumber = 108,
    kInterleaveBatchSizeFieldNumber = 134,
    kMaxPresolveIterationsFieldNumber = 138,
    kUseExactLpReasonFieldNumber = 109,
    kCatchSigintSignalFieldNumber = 135,
    kUseImpliedBoundsFieldNumber = 144,
    kConvertIntervalsFieldNumber = 177,
    kMergeNoOverlapWorkLimitFieldNumber = 145,
    kAddCgCutsFieldNumber = 117,
    kAddMirCutsFieldNumber = 120,
    kAddZeroHalfCutsFieldNumber = 169,
    kAddCliqueCutsFieldNumber = 172,
    kPresolveSubstitutionLevelFieldNumber = 147,
    kMergeAtMostOneWorkLimitFieldNumber = 146,
    kMaxAllDiffCutSizeFieldNumber = 148,
    kHintConflictLimitFieldNumber = 153,
    kCutMaxActiveCountValueFieldNumber = 155,
    kMaxCutRoundsAtLevelZeroFieldNumber = 154,
    kCutCleanupTargetFieldNumber = 157,
    kCutActiveCountDecayFieldNumber = 156,
    kAbsoluteGapLimitFieldNumber = 159,
    kFpRoundingFieldNumber = 165,
    kPolarityRephaseIncrementFieldNumber = 168,
    kMipAutomaticallyScaleVariablesFieldNumber = 166,
    kMipComputeTrueObjectiveBoundFieldNumber = 198,
    kSymmetryLevelFieldNumber = 183,
    kClauseCleanupRatioFieldNumber = 190,
    kMaxDomainSizeWhenEncodingEqNeqConstraintsFieldNumber = 191,
    kSolutionPoolSizeFieldNumber = 193,
    kMipMaxValidMagnitudeFieldNumber = 199,
  };
  // 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;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_default_restart_algorithms(ArgT0&& arg0, ArgT... args);
  std::string* mutable_default_restart_algorithms();
  PROTOBUF_NODISCARD std::string* release_default_restart_algorithms();
  void set_allocated_default_restart_algorithms(std::string* default_restart_algorithms);
  private:
  const std::string& _internal_default_restart_algorithms() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_restart_algorithms(const std::string& value);
  std::string* _internal_mutable_default_restart_algorithms();
  public:
 
  // optional string name = 171 [default = ""];
  bool has_name() const;
  private:
  bool _internal_has_name() const;
  public:
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:
 
  // optional string log_prefix = 185 [default = ""];
  bool has_log_prefix() const;
  private:
  bool _internal_has_log_prefix() const;
  public:
  void clear_log_prefix();
  const std::string& log_prefix() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_log_prefix(ArgT0&& arg0, ArgT... args);
  std::string* mutable_log_prefix();
  PROTOBUF_NODISCARD std::string* release_log_prefix();
  void set_allocated_log_prefix(std::string* log_prefix);
  private:
  const std::string& _internal_log_prefix() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_log_prefix(const std::string& value);
  std::string* _internal_mutable_log_prefix();
  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 int32 clause_cleanup_target = 13 [default = 0];
  bool has_clause_cleanup_target() const;
  private:
  bool _internal_has_clause_cleanup_target() const;
  public:
  void clear_clause_cleanup_target();
  int32_t clause_cleanup_target() const;
  void set_clause_cleanup_target(int32_t value);
  private:
  int32_t _internal_clause_cleanup_target() const;
  void _internal_set_clause_cleanup_target(int32_t 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.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 .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 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();
  int32_t num_conflicts_before_strategy_changes() const;
  void set_num_conflicts_before_strategy_changes(int32_t value);
  private:
  int32_t _internal_num_conflicts_before_strategy_changes() const;
  void _internal_set_num_conflicts_before_strategy_changes(int32_t 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 .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 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 permute_variable_randomly = 178 [default = false];
  bool has_permute_variable_randomly() const;
  private:
  bool _internal_has_permute_variable_randomly() const;
  public:
  void clear_permute_variable_randomly();
  bool permute_variable_randomly() const;
  void set_permute_variable_randomly(bool value);
  private:
  bool _internal_permute_variable_randomly() const;
  void _internal_set_permute_variable_randomly(bool value);
  public:
 
  // optional int32 num_search_workers = 100 [default = 0];
  bool has_num_search_workers() const;
  private:
  bool _internal_has_num_search_workers() const;
  public:
  void clear_num_search_workers();
  int32_t num_search_workers() const;
  void set_num_search_workers(int32_t value);
  private:
  int32_t _internal_num_search_workers() const;
  void _internal_set_num_search_workers(int32_t 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 use_cumulative_in_no_overlap_2d = 200 [default = false];
  bool has_use_cumulative_in_no_overlap_2d() const;
  private:
  bool _internal_has_use_cumulative_in_no_overlap_2d() const;
  public:
  void clear_use_cumulative_in_no_overlap_2d();
  bool use_cumulative_in_no_overlap_2d() const;
  void set_use_cumulative_in_no_overlap_2d(bool value);
  private:
  bool _internal_use_cumulative_in_no_overlap_2d() const;
  void _internal_set_use_cumulative_in_no_overlap_2d(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();
  int64_t search_randomization_tolerance() const;
  void set_search_randomization_tolerance(int64_t value);
  private:
  int64_t _internal_search_randomization_tolerance() const;
  void _internal_set_search_randomization_tolerance(int64_t 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 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 bool expand_alldiff_constraints = 170 [default = false];
  bool has_expand_alldiff_constraints() const;
  private:
  bool _internal_has_expand_alldiff_constraints() const;
  public:
  void clear_expand_alldiff_constraints();
  bool expand_alldiff_constraints() const;
  void set_expand_alldiff_constraints(bool value);
  private:
  bool _internal_expand_alldiff_constraints() const;
  void _internal_set_expand_alldiff_constraints(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 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 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_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 optimize_with_lb_tree_search = 188 [default = false];
  bool has_optimize_with_lb_tree_search() const;
  private:
  bool _internal_has_optimize_with_lb_tree_search() const;
  public:
  void clear_optimize_with_lb_tree_search();
  bool optimize_with_lb_tree_search() const;
  void set_optimize_with_lb_tree_search(bool value);
  private:
  bool _internal_optimize_with_lb_tree_search() const;
  void _internal_set_optimize_with_lb_tree_search(bool 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 keep_all_feasible_solutions_in_presolve = 173 [default = false];
  bool has_keep_all_feasible_solutions_in_presolve() const;
  private:
  bool _internal_has_keep_all_feasible_solutions_in_presolve() const;
  public:
  void clear_keep_all_feasible_solutions_in_presolve();
  bool keep_all_feasible_solutions_in_presolve() const;
  void set_keep_all_feasible_solutions_in_presolve(bool value);
  private:
  bool _internal_keep_all_feasible_solutions_in_presolve() const;
  void _internal_set_keep_all_feasible_solutions_in_presolve(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 use_probing_search = 176 [default = false];
  bool has_use_probing_search() const;
  private:
  bool _internal_has_use_probing_search() const;
  public:
  void clear_use_probing_search();
  bool use_probing_search() const;
  void set_use_probing_search(bool value);
  private:
  bool _internal_use_probing_search() const;
  void _internal_set_use_probing_search(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 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 fill_additional_solutions_in_response = 194 [default = false];
  bool has_fill_additional_solutions_in_response() const;
  private:
  bool _internal_has_fill_additional_solutions_in_response() const;
  public:
  void clear_fill_additional_solutions_in_response();
  bool fill_additional_solutions_in_response() const;
  void set_fill_additional_solutions_in_response(bool value);
  private:
  bool _internal_fill_additional_solutions_in_response() const;
  void _internal_set_fill_additional_solutions_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 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 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();
  int64_t probing_period_at_root() const;
  void set_probing_period_at_root(int64_t value);
  private:
  int64_t _internal_probing_period_at_root() const;
  void _internal_set_probing_period_at_root(int64_t value);
  public:
 
  // optional bool permute_presolve_constraint_order = 179 [default = false];
  bool has_permute_presolve_constraint_order() const;
  private:
  bool _internal_has_permute_presolve_constraint_order() const;
  public:
  void clear_permute_presolve_constraint_order();
  bool permute_presolve_constraint_order() const;
  void set_permute_presolve_constraint_order(bool value);
  private:
  bool _internal_permute_presolve_constraint_order() const;
  void _internal_set_permute_presolve_constraint_order(bool value);
  public:
 
  // optional bool use_absl_random = 180 [default = false];
  bool has_use_absl_random() const;
  private:
  bool _internal_has_use_absl_random() const;
  public:
  void clear_use_absl_random();
  bool use_absl_random() const;
  void set_use_absl_random(bool value);
  private:
  bool _internal_use_absl_random() const;
  void _internal_set_use_absl_random(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 bool log_to_response = 187 [default = false];
  bool has_log_to_response() const;
  private:
  bool _internal_has_log_to_response() const;
  public:
  void clear_log_to_response();
  bool log_to_response() const;
  void set_log_to_response(bool value);
  private:
  bool _internal_log_to_response() const;
  void _internal_set_log_to_response(bool value);
  public:
 
  // optional int32 debug_max_num_presolve_operations = 151 [default = 0];
  bool has_debug_max_num_presolve_operations() const;
  private:
  bool _internal_has_debug_max_num_presolve_operations() const;
  public:
  void clear_debug_max_num_presolve_operations();
  int32_t debug_max_num_presolve_operations() const;
  void set_debug_max_num_presolve_operations(int32_t value);
  private:
  int32_t _internal_debug_max_num_presolve_operations() const;
  void _internal_set_debug_max_num_presolve_operations(int32_t 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 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 bool add_objective_cut = 197 [default = false];
  bool has_add_objective_cut() const;
  private:
  bool _internal_has_add_objective_cut() const;
  public:
  void clear_add_objective_cut();
  bool add_objective_cut() const;
  void set_add_objective_cut(bool value);
  private:
  bool _internal_add_objective_cut() const;
  void _internal_set_add_objective_cut(bool value);
  public:
 
  // optional bool repair_hint = 167 [default = false];
  bool has_repair_hint() const;
  private:
  bool _internal_has_repair_hint() const;
  public:
  void clear_repair_hint();
  bool repair_hint() const;
  void set_repair_hint(bool value);
  private:
  bool _internal_repair_hint() const;
  void _internal_set_repair_hint(bool value);
  public:
 
  // optional bool fix_variables_to_their_hinted_value = 192 [default = false];
  bool has_fix_variables_to_their_hinted_value() const;
  private:
  bool _internal_has_fix_variables_to_their_hinted_value() const;
  public:
  void clear_fix_variables_to_their_hinted_value();
  bool fix_variables_to_their_hinted_value() const;
  void set_fix_variables_to_their_hinted_value(bool value);
  private:
  bool _internal_fix_variables_to_their_hinted_value() const;
  void _internal_set_fix_variables_to_their_hinted_value(bool value);
  public:
 
  // optional bool polish_lp_solution = 175 [default = false];
  bool has_polish_lp_solution() const;
  private:
  bool _internal_has_polish_lp_solution() const;
  public:
  void clear_polish_lp_solution();
  bool polish_lp_solution() const;
  void set_polish_lp_solution(bool value);
  private:
  bool _internal_polish_lp_solution() const;
  void _internal_set_polish_lp_solution(bool value);
  public:
 
  // optional bool disable_constraint_expansion = 181 [default = false];
  bool has_disable_constraint_expansion() const;
  private:
  bool _internal_has_disable_constraint_expansion() const;
  public:
  void clear_disable_constraint_expansion();
  bool disable_constraint_expansion() const;
  void set_disable_constraint_expansion(bool value);
  private:
  bool _internal_disable_constraint_expansion() const;
  void _internal_set_disable_constraint_expansion(bool value);
  public:
 
  // optional bool presolve_extract_integer_enforcement = 174 [default = false];
  bool has_presolve_extract_integer_enforcement() const;
  private:
  bool _internal_has_presolve_extract_integer_enforcement() const;
  public:
  void clear_presolve_extract_integer_enforcement();
  bool presolve_extract_integer_enforcement() const;
  void set_presolve_extract_integer_enforcement(bool value);
  private:
  bool _internal_presolve_extract_integer_enforcement() const;
  void _internal_set_presolve_extract_integer_enforcement(bool value);
  public:
 
  // optional bool debug_postsolve_with_full_solver = 162 [default = false];
  bool has_debug_postsolve_with_full_solver() const;
  private:
  bool _internal_has_debug_postsolve_with_full_solver() const;
  public:
  void clear_debug_postsolve_with_full_solver();
  bool debug_postsolve_with_full_solver() const;
  void set_debug_postsolve_with_full_solver(bool value);
  private:
  bool _internal_debug_postsolve_with_full_solver() const;
  void _internal_set_debug_postsolve_with_full_solver(bool value);
  public:
 
  // optional bool debug_crash_on_bad_hint = 195 [default = false];
  bool has_debug_crash_on_bad_hint() const;
  private:
  bool _internal_has_debug_crash_on_bad_hint() const;
  public:
  void clear_debug_crash_on_bad_hint();
  bool debug_crash_on_bad_hint() const;
  void set_debug_crash_on_bad_hint(bool value);
  private:
  bool _internal_debug_crash_on_bad_hint() const;
  void _internal_set_debug_crash_on_bad_hint(bool value);
  public:
 
  // optional int32 cut_level = 196 [default = 1];
  bool has_cut_level() const;
  private:
  bool _internal_has_cut_level() const;
  public:
  void clear_cut_level();
  int32_t cut_level() const;
  void set_cut_level(int32_t value);
  private:
  int32_t _internal_cut_level() const;
  void _internal_set_cut_level(int32_t 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 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 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();
  int32_t clause_cleanup_period() const;
  void set_clause_cleanup_period(int32_t value);
  private:
  int32_t _internal_clause_cleanup_period() const;
  void _internal_set_clause_cleanup_period(int32_t 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();
  int32_t glucose_decay_increment_period() const;
  void set_glucose_decay_increment_period(int32_t value);
  private:
  int32_t _internal_glucose_decay_increment_period() const;
  void _internal_set_glucose_decay_increment_period(int32_t 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 restart_period = 30 [default = 50];
  bool has_restart_period() const;
  private:
  bool _internal_has_restart_period() const;
  public:
  void clear_restart_period();
  int32_t restart_period() const;
  void set_restart_period(int32_t value);
  private:
  int32_t _internal_restart_period() const;
  void _internal_set_restart_period(int32_t 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();
  int32_t random_seed() const;
  void set_random_seed(int32_t value);
  private:
  int32_t _internal_random_seed() const;
  void _internal_set_random_seed(int32_t 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();
  int64_t max_number_of_conflicts() const;
  void set_max_number_of_conflicts(int64_t value);
  private:
  int64_t _internal_max_number_of_conflicts() const;
  void _internal_set_max_number_of_conflicts(int64_t 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();
  int64_t max_memory_in_mb() const;
  void set_max_memory_in_mb(int64_t value);
  private:
  int64_t _internal_max_memory_in_mb() const;
  void _internal_set_max_memory_in_mb(int64_t 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 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();
  int32_t pb_cleanup_increment() const;
  void set_pb_cleanup_increment(int32_t value);
  private:
  int32_t _internal_pb_cleanup_increment() const;
  void _internal_set_pb_cleanup_increment(int32_t 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();
  int32_t presolve_bve_threshold() const;
  void set_presolve_bve_threshold(int32_t value);
  private:
  int32_t _internal_presolve_bve_threshold() const;
  void _internal_set_presolve_bve_threshold(int32_t 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();
  int32_t presolve_bve_clause_weight() const;
  void set_presolve_bve_clause_weight(int32_t value);
  private:
  int32_t _internal_presolve_bve_clause_weight() const;
  void _internal_set_presolve_bve_clause_weight(int32_t 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();
  int32_t clause_cleanup_lbd_bound() const;
  void set_clause_cleanup_lbd_bound(int32_t value);
  private:
  int32_t _internal_clause_cleanup_lbd_bound() const;
  void _internal_set_clause_cleanup_lbd_bound(int32_t 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();
  int32_t restart_running_window_size() const;
  void set_restart_running_window_size(int32_t value);
  private:
  int32_t _internal_restart_running_window_size() const;
  void _internal_set_restart_running_window_size(int32_t 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();
  int32_t blocking_restart_window_size() const;
  void set_blocking_restart_window_size(int32_t value);
  private:
  int32_t _internal_blocking_restart_window_size() const;
  void _internal_set_blocking_restart_window_size(int32_t 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 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 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 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 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();
  int32_t presolve_bva_threshold() const;
  void set_presolve_bva_threshold(int32_t value);
  private:
  int32_t _internal_presolve_bva_threshold() const;
  void _internal_set_presolve_bva_threshold(int32_t 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 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 log_subsolver_statistics = 189 [default = true];
  bool has_log_subsolver_statistics() const;
  private:
  bool _internal_has_log_subsolver_statistics() const;
  public:
  void clear_log_subsolver_statistics();
  bool log_subsolver_statistics() const;
  void set_log_subsolver_statistics(bool value);
  private:
  bool _internal_log_subsolver_statistics() const;
  void _internal_set_log_subsolver_statistics(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 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 int32 linearization_level = 90 [default = 1];
  bool has_linearization_level() const;
  private:
  bool _internal_has_linearization_level() const;
  public:
  void clear_linearization_level();
  int32_t linearization_level() const;
  void set_linearization_level(int32_t value);
  private:
  int32_t _internal_linearization_level() const;
  void _internal_set_linearization_level(int32_t 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();
  int32_t max_num_cuts() const;
  void set_max_num_cuts(int32_t value);
  private:
  int32_t _internal_max_num_cuts() const;
  void _internal_set_max_num_cuts(int32_t 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();
  int32_t minimize_with_propagation_restart_period() const;
  void set_minimize_with_propagation_restart_period(int32_t value);
  private:
  int32_t _internal_minimize_with_propagation_restart_period() const;
  void _internal_set_minimize_with_propagation_restart_period(int32_t 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();
  int32_t minimize_with_propagation_num_decisions() const;
  void set_minimize_with_propagation_num_decisions(int32_t value);
  private:
  int32_t _internal_minimize_with_propagation_num_decisions() const;
  void _internal_set_minimize_with_propagation_num_decisions(int32_t value);
  public:
 
  // optional bool log_to_stdout = 186 [default = true];
  bool has_log_to_stdout() const;
  private:
  bool _internal_has_log_to_stdout() const;
  public:
  void clear_log_to_stdout();
  bool log_to_stdout() const;
  void set_log_to_stdout(bool value);
  private:
  bool _internal_log_to_stdout() const;
  void _internal_set_log_to_stdout(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 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 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();
  int32_t binary_search_num_conflicts() const;
  void set_binary_search_num_conflicts(int32_t value);
  private:
  int32_t _internal_binary_search_num_conflicts() const;
  void _internal_set_binary_search_num_conflicts(int32_t 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();
  int32_t boolean_encoding_level() const;
  void set_boolean_encoding_level(int32_t value);
  private:
  int32_t _internal_boolean_encoding_level() const;
  void _internal_set_boolean_encoding_level(int32_t 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();
  int32_t cp_model_probing_level() const;
  void set_cp_model_probing_level(int32_t value);
  private:
  int32_t _internal_cp_model_probing_level() const;
  void _internal_set_cp_model_probing_level(int32_t 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 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 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 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 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 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();
  int32_t max_integer_rounding_scaling() const;
  void set_max_integer_rounding_scaling(int32_t value);
  private:
  int32_t _internal_max_integer_rounding_scaling() const;
  void _internal_set_max_integer_rounding_scaling(int32_t 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();
  int32_t max_consecutive_inactive_count() const;
  void set_max_consecutive_inactive_count(int32_t value);
  private:
  int32_t _internal_max_consecutive_inactive_count() const;
  void _internal_set_max_consecutive_inactive_count(int32_t 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();
  int64_t pseudo_cost_reliability_threshold() const;
  void set_pseudo_cost_reliability_threshold(int64_t value);
  private:
  int64_t _internal_pseudo_cost_reliability_threshold() const;
  void _internal_set_pseudo_cost_reliability_threshold(int64_t 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 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();
  int32_t new_constraints_batch_size() const;
  void set_new_constraints_batch_size(int32_t value);
  private:
  int32_t _internal_new_constraints_batch_size() const;
  void _internal_set_new_constraints_batch_size(int32_t 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();
  int32_t mip_max_activity_exponent() const;
  void set_mip_max_activity_exponent(int32_t value);
  private:
  int32_t _internal_mip_max_activity_exponent() const;
  void _internal_set_mip_max_activity_exponent(int32_t 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 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 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 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 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();
  int32_t interleave_batch_size() const;
  void set_interleave_batch_size(int32_t value);
  private:
  int32_t _internal_interleave_batch_size() const;
  void _internal_set_interleave_batch_size(int32_t 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();
  int32_t max_presolve_iterations() const;
  void set_max_presolve_iterations(int32_t value);
  private:
  int32_t _internal_max_presolve_iterations() const;
  void _internal_set_max_presolve_iterations(int32_t 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 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 convert_intervals = 177 [default = true];
  bool has_convert_intervals() const;
  private:
  bool _internal_has_convert_intervals() const;
  public:
  void clear_convert_intervals();
  bool convert_intervals() const;
  void set_convert_intervals(bool value);
  private:
  bool _internal_convert_intervals() const;
  void _internal_set_convert_intervals(bool 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 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_zero_half_cuts = 169 [default = true];
  bool has_add_zero_half_cuts() const;
  private:
  bool _internal_has_add_zero_half_cuts() const;
  public:
  void clear_add_zero_half_cuts();
  bool add_zero_half_cuts() const;
  void set_add_zero_half_cuts(bool value);
  private:
  bool _internal_add_zero_half_cuts() const;
  void _internal_set_add_zero_half_cuts(bool value);
  public:
 
  // optional bool add_clique_cuts = 172 [default = true];
  bool has_add_clique_cuts() const;
  private:
  bool _internal_has_add_clique_cuts() const;
  public:
  void clear_add_clique_cuts();
  bool add_clique_cuts() const;
  void set_add_clique_cuts(bool value);
  private:
  bool _internal_add_clique_cuts() const;
  void _internal_set_add_clique_cuts(bool 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();
  int32_t presolve_substitution_level() const;
  void set_presolve_substitution_level(int32_t value);
  private:
  int32_t _internal_presolve_substitution_level() const;
  void _internal_set_presolve_substitution_level(int32_t 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 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();
  int32_t max_all_diff_cut_size() const;
  void set_max_all_diff_cut_size(int32_t value);
  private:
  int32_t _internal_max_all_diff_cut_size() const;
  void _internal_set_max_all_diff_cut_size(int32_t 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();
  int32_t hint_conflict_limit() const;
  void set_hint_conflict_limit(int32_t value);
  private:
  int32_t _internal_hint_conflict_limit() const;
  void _internal_set_hint_conflict_limit(int32_t 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();
  int32_t max_cut_rounds_at_level_zero() const;
  void set_max_cut_rounds_at_level_zero(int32_t value);
  private:
  int32_t _internal_max_cut_rounds_at_level_zero() const;
  void _internal_set_max_cut_rounds_at_level_zero(int32_t 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();
  int32_t cut_cleanup_target() const;
  void set_cut_cleanup_target(int32_t value);
  private:
  int32_t _internal_cut_cleanup_target() const;
  void _internal_set_cut_cleanup_target(int32_t 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:
 
  // optional double absolute_gap_limit = 159 [default = 0.0001];
  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 .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 int32 polarity_rephase_increment = 168 [default = 1000];
  bool has_polarity_rephase_increment() const;
  private:
  bool _internal_has_polarity_rephase_increment() const;
  public:
  void clear_polarity_rephase_increment();
  int32_t polarity_rephase_increment() const;
  void set_polarity_rephase_increment(int32_t value);
  private:
  int32_t _internal_polarity_rephase_increment() const;
  void _internal_set_polarity_rephase_increment(int32_t 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 bool mip_compute_true_objective_bound = 198 [default = true];
  bool has_mip_compute_true_objective_bound() const;
  private:
  bool _internal_has_mip_compute_true_objective_bound() const;
  public:
  void clear_mip_compute_true_objective_bound();
  bool mip_compute_true_objective_bound() const;
  void set_mip_compute_true_objective_bound(bool value);
  private:
  bool _internal_mip_compute_true_objective_bound() const;
  void _internal_set_mip_compute_true_objective_bound(bool value);
  public:
 
  // optional int32 symmetry_level = 183 [default = 2];
  bool has_symmetry_level() const;
  private:
  bool _internal_has_symmetry_level() const;
  public:
  void clear_symmetry_level();
  int32_t symmetry_level() const;
  void set_symmetry_level(int32_t value);
  private:
  int32_t _internal_symmetry_level() const;
  void _internal_set_symmetry_level(int32_t value);
  public:
 
  // optional double clause_cleanup_ratio = 190 [default = 0.5];
  bool has_clause_cleanup_ratio() const;
  private:
  bool _internal_has_clause_cleanup_ratio() const;
  public:
  void clear_clause_cleanup_ratio();
  double clause_cleanup_ratio() const;
  void set_clause_cleanup_ratio(double value);
  private:
  double _internal_clause_cleanup_ratio() const;
  void _internal_set_clause_cleanup_ratio(double value);
  public:
 
  // optional int32 max_domain_size_when_encoding_eq_neq_constraints = 191 [default = 16];
  bool has_max_domain_size_when_encoding_eq_neq_constraints() const;
  private:
  bool _internal_has_max_domain_size_when_encoding_eq_neq_constraints() const;
  public:
  void clear_max_domain_size_when_encoding_eq_neq_constraints();
  int32_t max_domain_size_when_encoding_eq_neq_constraints() const;
  void set_max_domain_size_when_encoding_eq_neq_constraints(int32_t value);
  private:
  int32_t _internal_max_domain_size_when_encoding_eq_neq_constraints() const;
  void _internal_set_max_domain_size_when_encoding_eq_neq_constraints(int32_t value);
  public:
 
  // optional int32 solution_pool_size = 193 [default = 3];
  bool has_solution_pool_size() const;
  private:
  bool _internal_has_solution_pool_size() const;
  public:
  void clear_solution_pool_size();
  int32_t solution_pool_size() const;
  void set_solution_pool_size(int32_t value);
  private:
  int32_t _internal_solution_pool_size() const;
  void _internal_set_solution_pool_size(int32_t value);
  public:
 
  // optional double mip_max_valid_magnitude = 199 [default = 1e+30];
  bool has_mip_max_valid_magnitude() const;
  private:
  bool _internal_has_mip_max_valid_magnitude() const;
  public:
  void clear_mip_max_valid_magnitude();
  double mip_max_valid_magnitude() const;
  void set_mip_max_valid_magnitude(double value);
  private:
  double _internal_mip_max_valid_magnitude() const;
  void _internal_set_mip_max_valid_magnitude(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<6> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> restart_algorithms_;
  static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_default_restart_algorithms_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_restart_algorithms_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr log_prefix_;
  int preferred_variable_order_;
  int32_t clause_cleanup_target_;
  double random_branches_ratio_;
  double random_polarity_ratio_;
  int max_sat_assumption_order_;
  int clause_cleanup_protection_;
  int clause_cleanup_ordering_;
  int32_t num_conflicts_before_strategy_changes_;
  double strategy_change_increase_ratio_;
  double initial_variables_activity_;
  int search_branching_;
  bool use_erwa_heuristic_;
  bool also_bump_variables_in_conflict_reasons_;
  bool use_blocking_restart_;
  bool permute_variable_randomly_;
  int32_t num_search_workers_;
  bool max_sat_reverse_assumption_order_;
  bool use_overload_checker_in_cumulative_constraint_;
  bool use_timetable_edge_finding_in_cumulative_constraint_;
  bool use_cumulative_in_no_overlap_2d_;
  int64_t search_randomization_tolerance_;
  bool use_pb_resolution_;
  bool minimize_reduction_during_pb_resolution_;
  bool use_sat_inprocessing_;
  bool expand_alldiff_constraints_;
  bool diversify_lns_params_;
  bool randomize_search_;
  bool use_branching_in_lp_;
  bool use_combined_no_overlap_;
  bool interleave_search_;
  bool reduce_memory_usage_in_interleave_mode_;
  bool use_lns_only_;
  bool use_relaxation_lns_;
  bool optimize_with_lb_tree_search_;
  bool optimize_with_max_hs_;
  bool enumerate_all_solutions_;
  bool keep_all_feasible_solutions_in_presolve_;
  bool exploit_best_solution_;
  bool exploit_relaxation_solution_;
  bool use_probing_search_;
  bool optimize_with_core_;
  bool fill_tightened_domains_in_response_;
  bool fill_additional_solutions_in_response_;
  bool stop_after_first_solution_;
  bool stop_after_presolve_;
  int64_t probing_period_at_root_;
  bool permute_presolve_constraint_order_;
  bool use_absl_random_;
  bool log_search_progress_;
  bool log_to_response_;
  int32_t debug_max_num_presolve_operations_;
  double relative_gap_limit_;
  bool only_add_cuts_at_level_zero_;
  bool add_objective_cut_;
  bool repair_hint_;
  bool fix_variables_to_their_hinted_value_;
  bool polish_lp_solution_;
  bool disable_constraint_expansion_;
  bool presolve_extract_integer_enforcement_;
  bool debug_postsolve_with_full_solver_;
  bool debug_crash_on_bad_hint_;
  int32_t cut_level_;
  int initial_polarity_;
  int minimization_algorithm_;
  double variable_activity_decay_;
  double max_variable_activity_value_;
  double clause_activity_decay_;
  int32_t clause_cleanup_period_;
  int32_t glucose_decay_increment_period_;
  double max_clause_activity_value_;
  double glucose_max_decay_;
  double glucose_decay_increment_;
  int32_t restart_period_;
  int32_t random_seed_;
  double max_time_in_seconds_;
  int64_t max_number_of_conflicts_;
  int64_t max_memory_in_mb_;
  int binary_minimization_algorithm_;
  int32_t pb_cleanup_increment_;
  double pb_cleanup_ratio_;
  int max_sat_stratification_;
  int32_t presolve_bve_threshold_;
  double presolve_probing_deterministic_time_limit_;
  int32_t presolve_bve_clause_weight_;
  int32_t clause_cleanup_lbd_bound_;
  double restart_dl_average_ratio_;
  int32_t restart_running_window_size_;
  int32_t blocking_restart_window_size_;
  double blocking_restart_multiplier_;
  double max_deterministic_time_;
  bool cp_model_presolve_;
  bool cp_model_use_sat_presolve_;
  bool use_optimization_hints_;
  bool minimize_core_;
  int32_t presolve_bva_threshold_;
  double restart_lbd_average_ratio_;
  bool use_phase_saving_;
  bool subsumption_during_conflict_analysis_;
  bool treat_binary_clauses_separately_;
  bool log_subsolver_statistics_;
  bool find_multiple_cores_;
  bool cover_optimization_;
  bool use_precedences_in_disjunctive_constraint_;
  bool use_disjunctive_constraint_in_cumulative_constraint_;
  int32_t linearization_level_;
  int32_t max_num_cuts_;
  int32_t minimize_with_propagation_restart_period_;
  int32_t minimize_with_propagation_num_decisions_;
  bool log_to_stdout_;
  bool count_assumption_levels_in_lbd_;
  bool presolve_blocked_clause_;
  bool presolve_use_bva_;
  int32_t binary_search_num_conflicts_;
  int32_t boolean_encoding_level_;
  int32_t cp_model_probing_level_;
  bool exploit_objective_;
  bool instantiate_all_variables_;
  bool auto_detect_greater_than_at_least_one_of_;
  bool share_objective_bounds_;
  bool add_lin_max_cuts_;
  bool add_lp_constraints_lazily_;
  bool exploit_integer_lp_solution_;
  bool exploit_all_lp_solution_;
  double min_orthogonality_for_lp_constraints_;
  int32_t max_integer_rounding_scaling_;
  int32_t max_consecutive_inactive_count_;
  int64_t pseudo_cost_reliability_threshold_;
  double mip_max_bound_;
  int32_t new_constraints_batch_size_;
  int32_t mip_max_activity_exponent_;
  double mip_var_scaling_;
  double mip_wanted_precision_;
  double mip_check_precision_;
  bool share_level_zero_bounds_;
  bool use_rins_lns_;
  bool use_feasibility_pump_;
  bool use_optional_variables_;
  int32_t interleave_batch_size_;
  int32_t max_presolve_iterations_;
  bool use_exact_lp_reason_;
  bool catch_sigint_signal_;
  bool use_implied_bounds_;
  bool convert_intervals_;
  double merge_no_overlap_work_limit_;
  bool add_cg_cuts_;
  bool add_mir_cuts_;
  bool add_zero_half_cuts_;
  bool add_clique_cuts_;
  int32_t presolve_substitution_level_;
  double merge_at_most_one_work_limit_;
  int32_t max_all_diff_cut_size_;
  int32_t hint_conflict_limit_;
  double cut_max_active_count_value_;
  int32_t max_cut_rounds_at_level_zero_;
  int32_t cut_cleanup_target_;
  double cut_active_count_decay_;
  double absolute_gap_limit_;
  int fp_rounding_;
  int32_t polarity_rephase_increment_;
  bool mip_automatically_scale_variables_;
  bool mip_compute_true_objective_bound_;
  int32_t symmetry_level_;
  double clause_cleanup_ratio_;
  int32_t max_domain_size_when_encoding_eq_neq_constraints_;
  int32_t solution_pool_size_;
  double mip_max_valid_magnitude_;
  friend struct ::TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto;
};
// ===================================================================
 
 
// ===================================================================
 
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// SatParameters
 
// optional string name = 171 [default = ""];
inline bool SatParameters::_internal_has_name() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool SatParameters::has_name() const {
  return _internal_has_name();
}
inline void SatParameters::clear_name() {
  name_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& SatParameters::name() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SatParameters::set_name(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000002u;
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.name)
}
inline std::string* SatParameters::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.name)
  return _s;
}
inline const std::string& SatParameters::_internal_name() const {
  return name_.Get();
}
inline void SatParameters::_internal_set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SatParameters::_internal_mutable_name() {
  _has_bits_[0] |= 0x00000002u;
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SatParameters::release_name() {
  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.name)
  if (!_internal_has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  auto* p = name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SatParameters::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.name)
}
 
// 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] & 0x00000008u) != 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] &= ~0x00000008u;
}
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] |= 0x00000008u;
  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_[2] & 0x00000002u) != 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_[2] &= ~0x00000002u;
}
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_[2] |= 0x00000002u;
  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_[3] & 0x00000008u) != 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_[3] &= ~0x00000008u;
}
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_[3] |= 0x00000008u;
  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 int32 polarity_rephase_increment = 168 [default = 1000];
inline bool SatParameters::_internal_has_polarity_rephase_increment() const {
  bool value = (_has_bits_[5] & 0x00000002u) != 0;
  return value;
}
inline bool SatParameters::has_polarity_rephase_increment() const {
  return _internal_has_polarity_rephase_increment();
}
inline void SatParameters::clear_polarity_rephase_increment() {
  polarity_rephase_increment_ = 1000;
  _has_bits_[5] &= ~0x00000002u;
}
inline int32_t SatParameters::_internal_polarity_rephase_increment() const {
  return polarity_rephase_increment_;
}
inline int32_t SatParameters::polarity_rephase_increment() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.polarity_rephase_increment)
  return _internal_polarity_rephase_increment();
}
inline void SatParameters::_internal_set_polarity_rephase_increment(int32_t value) {
  _has_bits_[5] |= 0x00000002u;
  polarity_rephase_increment_ = value;
}
inline void SatParameters::set_polarity_rephase_increment(int32_t value) {
  _internal_set_polarity_rephase_increment(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.polarity_rephase_increment)
}
 
// optional double random_polarity_ratio = 45 [default = 0];
inline bool SatParameters::_internal_has_random_polarity_ratio() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 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] &= ~0x00000040u;
}
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] |= 0x00000040u;
  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] & 0x00000020u) != 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] &= ~0x00000020u;
}
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] |= 0x00000020u;
  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] & 0x00004000u) != 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] &= ~0x00004000u;
}
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] |= 0x00004000u;
  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] & 0x00001000u) != 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] &= ~0x00001000u;
}
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] |= 0x00001000u;
  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] & 0x00008000u) != 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] &= ~0x00008000u;
}
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] |= 0x00008000u;
  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_[2] & 0x00000004u) != 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_[2] &= ~0x00000004u;
}
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_[2] |= 0x00000004u;
  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_[2] & 0x00010000u) != 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_[2] &= ~0x00010000u;
}
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_[2] |= 0x00010000u;
  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_[3] & 0x00000010u) != 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_[3] &= ~0x00000010u;
}
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_[3] |= 0x00000010u;
  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_[2] & 0x00000040u) != 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_[2] &= ~0x00000040u;
}
inline int32_t SatParameters::_internal_clause_cleanup_period() const {
  return clause_cleanup_period_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x00000040u;
  clause_cleanup_period_ = value;
}
inline void SatParameters::set_clause_cleanup_period(int32_t 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 = 0];
inline bool SatParameters::_internal_has_clause_cleanup_target() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 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_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline int32_t SatParameters::_internal_clause_cleanup_target() const {
  return clause_cleanup_target_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[0] |= 0x00000010u;
  clause_cleanup_target_ = value;
}
inline void SatParameters::set_clause_cleanup_target(int32_t value) {
  _internal_set_clause_cleanup_target(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_target)
}
 
// optional double clause_cleanup_ratio = 190 [default = 0.5];
inline bool SatParameters::_internal_has_clause_cleanup_ratio() const {
  bool value = (_has_bits_[5] & 0x00000020u) != 0;
  return value;
}
inline bool SatParameters::has_clause_cleanup_ratio() const {
  return _internal_has_clause_cleanup_ratio();
}
inline void SatParameters::clear_clause_cleanup_ratio() {
  clause_cleanup_ratio_ = 0.5;
  _has_bits_[5] &= ~0x00000020u;
}
inline double SatParameters::_internal_clause_cleanup_ratio() const {
  return clause_cleanup_ratio_;
}
inline double SatParameters::clause_cleanup_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_ratio)
  return _internal_clause_cleanup_ratio();
}
inline void SatParameters::_internal_set_clause_cleanup_ratio(double value) {
  _has_bits_[5] |= 0x00000020u;
  clause_cleanup_ratio_ = value;
}
inline void SatParameters::set_clause_cleanup_ratio(double value) {
  _internal_set_clause_cleanup_ratio(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_ratio)
}
 
// 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] & 0x00000100u) != 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] &= ~0x00000100u;
}
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] |= 0x00000100u;
  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] & 0x00800000u) != 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] &= ~0x00800000u;
}
inline int32_t SatParameters::_internal_clause_cleanup_lbd_bound() const {
  return clause_cleanup_lbd_bound_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x00800000u;
  clause_cleanup_lbd_bound_ = value;
}
inline void SatParameters::set_clause_cleanup_lbd_bound(int32_t 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] & 0x00000200u) != 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] &= ~0x00000200u;
}
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] |= 0x00000200u;
  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] & 0x00020000u) != 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] &= ~0x00020000u;
}
inline int32_t SatParameters::_internal_pb_cleanup_increment() const {
  return pb_cleanup_increment_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x00020000u;
  pb_cleanup_increment_ = value;
}
inline void SatParameters::set_pb_cleanup_increment(int32_t 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] & 0x00040000u) != 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] &= ~0x00040000u;
}
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] |= 0x00040000u;
  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_[3] & 0x00002000u) != 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_[3] &= ~0x00002000u;
}
inline int32_t SatParameters::_internal_minimize_with_propagation_restart_period() const {
  return minimize_with_propagation_restart_period_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x00002000u;
  minimize_with_propagation_restart_period_ = value;
}
inline void SatParameters::set_minimize_with_propagation_restart_period(int32_t 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_[3] & 0x00004000u) != 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_[3] &= ~0x00004000u;
}
inline int32_t SatParameters::_internal_minimize_with_propagation_num_decisions() const {
  return minimize_with_propagation_num_decisions_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x00004000u;
  minimize_with_propagation_num_decisions_ = value;
}
inline void SatParameters::set_minimize_with_propagation_num_decisions(int32_t 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_[2] & 0x00000008u) != 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_[2] &= ~0x00000008u;
}
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_[2] |= 0x00000008u;
  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_[2] & 0x00000010u) != 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_[2] &= ~0x00000010u;
}
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_[2] |= 0x00000010u;
  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_[2] & 0x00000200u) != 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_[2] &= ~0x00000200u;
}
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_[2] |= 0x00000200u;
  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_[2] & 0x00000400u) != 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_[2] &= ~0x00000400u;
}
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_[2] |= 0x00000400u;
  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_[2] & 0x00000080u) != 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_[2] &= ~0x00000080u;
}
inline int32_t SatParameters::_internal_glucose_decay_increment_period() const {
  return glucose_decay_increment_period_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x00000080u;
  glucose_decay_increment_period_ = value;
}
inline void SatParameters::set_glucose_decay_increment_period(int32_t 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_[2] & 0x00000020u) != 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_[2] &= ~0x00000020u;
}
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_[2] |= 0x00000020u;
  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_[2] & 0x00000100u) != 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_[2] &= ~0x00000100u;
}
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_[2] |= 0x00000100u;
  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) {
  _internal_add_restart_algorithms(value);
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.restart_algorithms)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
SatParameters::restart_algorithms() const {
  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.restart_algorithms)
  return restart_algorithms_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
SatParameters::_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_, GetArenaForAllocation());
  _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)
  if (default_restart_algorithms_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_default_restart_algorithms_.get();
  return _internal_default_restart_algorithms();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SatParameters::set_default_restart_algorithms(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000001u;
 default_restart_algorithms_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline std::string* SatParameters::mutable_default_restart_algorithms() {
  std::string* _s = _internal_mutable_default_restart_algorithms();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.default_restart_algorithms)
  return _s;
}
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(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
}
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_, GetArenaForAllocation());
}
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;
  auto* p = default_restart_algorithms_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
  return p;
}
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(nullptr, default_restart_algorithms,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_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_[2] & 0x00000800u) != 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_[2] &= ~0x00000800u;
}
inline int32_t SatParameters::_internal_restart_period() const {
  return restart_period_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x00000800u;
  restart_period_ = value;
}
inline void SatParameters::set_restart_period(int32_t 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] & 0x02000000u) != 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] &= ~0x02000000u;
}
inline int32_t SatParameters::_internal_restart_running_window_size() const {
  return restart_running_window_size_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x02000000u;
  restart_running_window_size_ = value;
}
inline void SatParameters::set_restart_running_window_size(int32_t 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] & 0x01000000u) != 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] &= ~0x01000000u;
}
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] |= 0x01000000u;
  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_[3] & 0x00000004u) != 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_[3] &= ~0x00000004u;
}
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_[3] |= 0x00000004u;
  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] & 0x00010000u) != 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] &= ~0x00010000u;
}
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] |= 0x00010000u;
  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] & 0x04000000u) != 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] &= ~0x04000000u;
}
inline int32_t SatParameters::_internal_blocking_restart_window_size() const {
  return blocking_restart_window_size_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x04000000u;
  blocking_restart_window_size_ = value;
}
inline void SatParameters::set_blocking_restart_window_size(int32_t 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] & 0x08000000u) != 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] &= ~0x08000000u;
}
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] |= 0x08000000u;
  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] & 0x00000400u) != 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] &= ~0x00000400u;
}
inline int32_t SatParameters::_internal_num_conflicts_before_strategy_changes() const {
  return num_conflicts_before_strategy_changes_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[0] |= 0x00000400u;
  num_conflicts_before_strategy_changes_ = value;
}
inline void SatParameters::set_num_conflicts_before_strategy_changes(int32_t 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] & 0x00000800u) != 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] &= ~0x00000800u;
}
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] |= 0x00000800u;
  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_[2] & 0x00002000u) != 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_[2] &= ~0x00002000u;
}
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_[2] |= 0x00002000u;
  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] & 0x10000000u) != 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] &= ~0x10000000u;
}
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] |= 0x10000000u;
  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_[2] & 0x00004000u) != 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_ = int64_t{9223372036854775807};
  _has_bits_[2] &= ~0x00004000u;
}
inline int64_t SatParameters::_internal_max_number_of_conflicts() const {
  return max_number_of_conflicts_;
}
inline int64_t 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(int64_t value) {
  _has_bits_[2] |= 0x00004000u;
  max_number_of_conflicts_ = value;
}
inline void SatParameters::set_max_number_of_conflicts(int64_t 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_[2] & 0x00008000u) != 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_ = int64_t{10000};
  _has_bits_[2] &= ~0x00008000u;
}
inline int64_t SatParameters::_internal_max_memory_in_mb() const {
  return max_memory_in_mb_;
}
inline int64_t 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(int64_t value) {
  _has_bits_[2] |= 0x00008000u;
  max_memory_in_mb_ = value;
}
inline void SatParameters::set_max_memory_in_mb(int64_t 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.0001];
inline bool SatParameters::_internal_has_absolute_gap_limit() const {
  bool value = (_has_bits_[4] & 0x80000000u) != 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.0001;
  _has_bits_[4] &= ~0x80000000u;
}
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_[4] |= 0x80000000u;
  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] & 0x00400000u) != 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] &= ~0x00400000u;
}
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] |= 0x00400000u;
  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_[3] & 0x00000020u) != 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_[3] &= ~0x00000020u;
}
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_[3] |= 0x00000020u;
  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_[2] & 0x00001000u) != 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_[2] &= ~0x00001000u;
}
inline int32_t SatParameters::_internal_random_seed() const {
  return random_seed_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x00001000u;
  random_seed_ = value;
}
inline void SatParameters::set_random_seed(int32_t value) {
  _internal_set_random_seed(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_seed)
}
 
// optional bool permute_variable_randomly = 178 [default = false];
inline bool SatParameters::_internal_has_permute_variable_randomly() const {
  bool value = (_has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool SatParameters::has_permute_variable_randomly() const {
  return _internal_has_permute_variable_randomly();
}
inline void SatParameters::clear_permute_variable_randomly() {
  permute_variable_randomly_ = false;
  _has_bits_[0] &= ~0x00020000u;
}
inline bool SatParameters::_internal_permute_variable_randomly() const {
  return permute_variable_randomly_;
}
inline bool SatParameters::permute_variable_randomly() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.permute_variable_randomly)
  return _internal_permute_variable_randomly();
}
inline void SatParameters::_internal_set_permute_variable_randomly(bool value) {
  _has_bits_[0] |= 0x00020000u;
  permute_variable_randomly_ = value;
}
inline void SatParameters::set_permute_variable_randomly(bool value) {
  _internal_set_permute_variable_randomly(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.permute_variable_randomly)
}
 
// optional bool permute_presolve_constraint_order = 179 [default = false];
inline bool SatParameters::_internal_has_permute_presolve_constraint_order() const {
  bool value = (_has_bits_[1] & 0x00020000u) != 0;
  return value;
}
inline bool SatParameters::has_permute_presolve_constraint_order() const {
  return _internal_has_permute_presolve_constraint_order();
}
inline void SatParameters::clear_permute_presolve_constraint_order() {
  permute_presolve_constraint_order_ = false;
  _has_bits_[1] &= ~0x00020000u;
}
inline bool SatParameters::_internal_permute_presolve_constraint_order() const {
  return permute_presolve_constraint_order_;
}
inline bool SatParameters::permute_presolve_constraint_order() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.permute_presolve_constraint_order)
  return _internal_permute_presolve_constraint_order();
}
inline void SatParameters::_internal_set_permute_presolve_constraint_order(bool value) {
  _has_bits_[1] |= 0x00020000u;
  permute_presolve_constraint_order_ = value;
}
inline void SatParameters::set_permute_presolve_constraint_order(bool value) {
  _internal_set_permute_presolve_constraint_order(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.permute_presolve_constraint_order)
}
 
// optional bool use_absl_random = 180 [default = false];
inline bool SatParameters::_internal_has_use_absl_random() const {
  bool value = (_has_bits_[1] & 0x00040000u) != 0;
  return value;
}
inline bool SatParameters::has_use_absl_random() const {
  return _internal_has_use_absl_random();
}
inline void SatParameters::clear_use_absl_random() {
  use_absl_random_ = false;
  _has_bits_[1] &= ~0x00040000u;
}
inline bool SatParameters::_internal_use_absl_random() const {
  return use_absl_random_;
}
inline bool SatParameters::use_absl_random() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_absl_random)
  return _internal_use_absl_random();
}
inline void SatParameters::_internal_set_use_absl_random(bool value) {
  _has_bits_[1] |= 0x00040000u;
  use_absl_random_ = value;
}
inline void SatParameters::set_use_absl_random(bool value) {
  _internal_set_use_absl_random(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_absl_random)
}
 
// optional bool log_search_progress = 41 [default = false];
inline bool SatParameters::_internal_has_log_search_progress() const {
  bool value = (_has_bits_[1] & 0x00080000u) != 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_[1] &= ~0x00080000u;
}
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_[1] |= 0x00080000u;
  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 log_subsolver_statistics = 189 [default = true];
inline bool SatParameters::_internal_has_log_subsolver_statistics() const {
  bool value = (_has_bits_[3] & 0x00000040u) != 0;
  return value;
}
inline bool SatParameters::has_log_subsolver_statistics() const {
  return _internal_has_log_subsolver_statistics();
}
inline void SatParameters::clear_log_subsolver_statistics() {
  log_subsolver_statistics_ = true;
  _has_bits_[3] &= ~0x00000040u;
}
inline bool SatParameters::_internal_log_subsolver_statistics() const {
  return log_subsolver_statistics_;
}
inline bool SatParameters::log_subsolver_statistics() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_subsolver_statistics)
  return _internal_log_subsolver_statistics();
}
inline void SatParameters::_internal_set_log_subsolver_statistics(bool value) {
  _has_bits_[3] |= 0x00000040u;
  log_subsolver_statistics_ = value;
}
inline void SatParameters::set_log_subsolver_statistics(bool value) {
  _internal_set_log_subsolver_statistics(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_subsolver_statistics)
}
 
// optional string log_prefix = 185 [default = ""];
inline bool SatParameters::_internal_has_log_prefix() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool SatParameters::has_log_prefix() const {
  return _internal_has_log_prefix();
}
inline void SatParameters::clear_log_prefix() {
  log_prefix_.ClearToEmpty();
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& SatParameters::log_prefix() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_prefix)
  return _internal_log_prefix();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void SatParameters::set_log_prefix(ArgT0&& arg0, ArgT... args) {
 _has_bits_[0] |= 0x00000004u;
 log_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_prefix)
}
inline std::string* SatParameters::mutable_log_prefix() {
  std::string* _s = _internal_mutable_log_prefix();
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.log_prefix)
  return _s;
}
inline const std::string& SatParameters::_internal_log_prefix() const {
  return log_prefix_.Get();
}
inline void SatParameters::_internal_set_log_prefix(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  log_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* SatParameters::_internal_mutable_log_prefix() {
  _has_bits_[0] |= 0x00000004u;
  return log_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* SatParameters::release_log_prefix() {
  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.log_prefix)
  if (!_internal_has_log_prefix()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  auto* p = log_prefix_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (log_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    log_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  return p;
}
inline void SatParameters::set_allocated_log_prefix(std::string* log_prefix) {
  if (log_prefix != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  log_prefix_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), log_prefix,
      GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (log_prefix_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
    log_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.log_prefix)
}
 
// optional bool log_to_stdout = 186 [default = true];
inline bool SatParameters::_internal_has_log_to_stdout() const {
  bool value = (_has_bits_[3] & 0x00008000u) != 0;
  return value;
}
inline bool SatParameters::has_log_to_stdout() const {
  return _internal_has_log_to_stdout();
}
inline void SatParameters::clear_log_to_stdout() {
  log_to_stdout_ = true;
  _has_bits_[3] &= ~0x00008000u;
}
inline bool SatParameters::_internal_log_to_stdout() const {
  return log_to_stdout_;
}
inline bool SatParameters::log_to_stdout() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_to_stdout)
  return _internal_log_to_stdout();
}
inline void SatParameters::_internal_set_log_to_stdout(bool value) {
  _has_bits_[3] |= 0x00008000u;
  log_to_stdout_ = value;
}
inline void SatParameters::set_log_to_stdout(bool value) {
  _internal_set_log_to_stdout(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_to_stdout)
}
 
// optional bool log_to_response = 187 [default = false];
inline bool SatParameters::_internal_has_log_to_response() const {
  bool value = (_has_bits_[1] & 0x00100000u) != 0;
  return value;
}
inline bool SatParameters::has_log_to_response() const {
  return _internal_has_log_to_response();
}
inline void SatParameters::clear_log_to_response() {
  log_to_response_ = false;
  _has_bits_[1] &= ~0x00100000u;
}
inline bool SatParameters::_internal_log_to_response() const {
  return log_to_response_;
}
inline bool SatParameters::log_to_response() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_to_response)
  return _internal_log_to_response();
}
inline void SatParameters::_internal_set_log_to_response(bool value) {
  _has_bits_[1] |= 0x00100000u;
  log_to_response_ = value;
}
inline void SatParameters::set_log_to_response(bool value) {
  _internal_set_log_to_response(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_to_response)
}
 
// optional bool use_pb_resolution = 43 [default = false];
inline bool SatParameters::_internal_has_use_pb_resolution() const {
  bool value = (_has_bits_[0] & 0x01000000u) != 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] &= ~0x01000000u;
}
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] |= 0x01000000u;
  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] & 0x02000000u) != 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] &= ~0x02000000u;
}
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] |= 0x02000000u;
  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_[3] & 0x00010000u) != 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_[3] &= ~0x00010000u;
}
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_[3] |= 0x00010000u;
  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] & 0x00100000u) != 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] &= ~0x00100000u;
}
inline int32_t SatParameters::_internal_presolve_bve_threshold() const {
  return presolve_bve_threshold_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x00100000u;
  presolve_bve_threshold_ = value;
}
inline void SatParameters::set_presolve_bve_threshold(int32_t 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] & 0x00400000u) != 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] &= ~0x00400000u;
}
inline int32_t SatParameters::_internal_presolve_bve_clause_weight() const {
  return presolve_bve_clause_weight_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[2] |= 0x00400000u;
  presolve_bve_clause_weight_ = value;
}
inline void SatParameters::set_presolve_bve_clause_weight(int32_t 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] & 0x00200000u) != 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] &= ~0x00200000u;
}
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] |= 0x00200000u;
  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_[3] & 0x00020000u) != 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_[3] &= ~0x00020000u;
}
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_[3] |= 0x00020000u;
  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_[3] & 0x00040000u) != 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_[3] &= ~0x00040000u;
}
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_[3] |= 0x00040000u;
  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_[3] & 0x00000002u) != 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_[3] &= ~0x00000002u;
}
inline int32_t SatParameters::_internal_presolve_bva_threshold() const {
  return presolve_bva_threshold_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x00000002u;
  presolve_bva_threshold_ = value;
}
inline void SatParameters::set_presolve_bva_threshold(int32_t 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] & 0x00002000u) != 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] &= ~0x00002000u;
}
inline int32_t SatParameters::_internal_max_presolve_iterations() const {
  return max_presolve_iterations_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x00002000u;
  max_presolve_iterations_ = value;
}
inline void SatParameters::set_max_presolve_iterations(int32_t 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] & 0x20000000u) != 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] &= ~0x20000000u;
}
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] |= 0x20000000u;
  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 int32 cp_model_probing_level = 110 [default = 2];
inline bool SatParameters::_internal_has_cp_model_probing_level() const {
  bool value = (_has_bits_[3] & 0x00200000u) != 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] &= ~0x00200000u;
}
inline int32_t SatParameters::_internal_cp_model_probing_level() const {
  return cp_model_probing_level_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x00200000u;
  cp_model_probing_level_ = value;
}
inline void SatParameters::set_cp_model_probing_level(int32_t 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] & 0x40000000u) != 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] &= ~0x40000000u;
}
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] |= 0x40000000u;
  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_alldiff_constraints = 170 [default = false];
inline bool SatParameters::_internal_has_expand_alldiff_constraints() const {
  bool value = (_has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool SatParameters::has_expand_alldiff_constraints() const {
  return _internal_has_expand_alldiff_constraints();
}
inline void SatParameters::clear_expand_alldiff_constraints() {
  expand_alldiff_constraints_ = false;
  _has_bits_[0] &= ~0x08000000u;
}
inline bool SatParameters::_internal_expand_alldiff_constraints() const {
  return expand_alldiff_constraints_;
}
inline bool SatParameters::expand_alldiff_constraints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_alldiff_constraints)
  return _internal_expand_alldiff_constraints();
}
inline void SatParameters::_internal_set_expand_alldiff_constraints(bool value) {
  _has_bits_[0] |= 0x08000000u;
  expand_alldiff_constraints_ = value;
}
inline void SatParameters::set_expand_alldiff_constraints(bool value) {
  _internal_set_expand_alldiff_constraints(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_alldiff_constraints)
}
 
// optional bool disable_constraint_expansion = 181 [default = false];
inline bool SatParameters::_internal_has_disable_constraint_expansion() const {
  bool value = (_has_bits_[1] & 0x10000000u) != 0;
  return value;
}
inline bool SatParameters::has_disable_constraint_expansion() const {
  return _internal_has_disable_constraint_expansion();
}
inline void SatParameters::clear_disable_constraint_expansion() {
  disable_constraint_expansion_ = false;
  _has_bits_[1] &= ~0x10000000u;
}
inline bool SatParameters::_internal_disable_constraint_expansion() const {
  return disable_constraint_expansion_;
}
inline bool SatParameters::disable_constraint_expansion() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.disable_constraint_expansion)
  return _internal_disable_constraint_expansion();
}
inline void SatParameters::_internal_set_disable_constraint_expansion(bool value) {
  _has_bits_[1] |= 0x10000000u;
  disable_constraint_expansion_ = value;
}
inline void SatParameters::set_disable_constraint_expansion(bool value) {
  _internal_set_disable_constraint_expansion(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.disable_constraint_expansion)
}
 
// 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] & 0x00040000u) != 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] &= ~0x00040000u;
}
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] |= 0x00040000u;
  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] & 0x01000000u) != 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] &= ~0x01000000u;
}
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] |= 0x01000000u;
  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] & 0x00800000u) != 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] &= ~0x00800000u;
}
inline int32_t SatParameters::_internal_presolve_substitution_level() const {
  return presolve_substitution_level_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x00800000u;
  presolve_substitution_level_ = value;
}
inline void SatParameters::set_presolve_substitution_level(int32_t value) {
  _internal_set_presolve_substitution_level(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_substitution_level)
}
 
// optional bool presolve_extract_integer_enforcement = 174 [default = false];
inline bool SatParameters::_internal_has_presolve_extract_integer_enforcement() const {
  bool value = (_has_bits_[1] & 0x20000000u) != 0;
  return value;
}
inline bool SatParameters::has_presolve_extract_integer_enforcement() const {
  return _internal_has_presolve_extract_integer_enforcement();
}
inline void SatParameters::clear_presolve_extract_integer_enforcement() {
  presolve_extract_integer_enforcement_ = false;
  _has_bits_[1] &= ~0x20000000u;
}
inline bool SatParameters::_internal_presolve_extract_integer_enforcement() const {
  return presolve_extract_integer_enforcement_;
}
inline bool SatParameters::presolve_extract_integer_enforcement() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_extract_integer_enforcement)
  return _internal_presolve_extract_integer_enforcement();
}
inline void SatParameters::_internal_set_presolve_extract_integer_enforcement(bool value) {
  _has_bits_[1] |= 0x20000000u;
  presolve_extract_integer_enforcement_ = value;
}
inline void SatParameters::set_presolve_extract_integer_enforcement(bool value) {
  _internal_set_presolve_extract_integer_enforcement(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_extract_integer_enforcement)
}
 
// optional bool debug_postsolve_with_full_solver = 162 [default = false];
inline bool SatParameters::_internal_has_debug_postsolve_with_full_solver() const {
  bool value = (_has_bits_[1] & 0x40000000u) != 0;
  return value;
}
inline bool SatParameters::has_debug_postsolve_with_full_solver() const {
  return _internal_has_debug_postsolve_with_full_solver();
}
inline void SatParameters::clear_debug_postsolve_with_full_solver() {
  debug_postsolve_with_full_solver_ = false;
  _has_bits_[1] &= ~0x40000000u;
}
inline bool SatParameters::_internal_debug_postsolve_with_full_solver() const {
  return debug_postsolve_with_full_solver_;
}
inline bool SatParameters::debug_postsolve_with_full_solver() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.debug_postsolve_with_full_solver)
  return _internal_debug_postsolve_with_full_solver();
}
inline void SatParameters::_internal_set_debug_postsolve_with_full_solver(bool value) {
  _has_bits_[1] |= 0x40000000u;
  debug_postsolve_with_full_solver_ = value;
}
inline void SatParameters::set_debug_postsolve_with_full_solver(bool value) {
  _internal_set_debug_postsolve_with_full_solver(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.debug_postsolve_with_full_solver)
}
 
// optional int32 debug_max_num_presolve_operations = 151 [default = 0];
inline bool SatParameters::_internal_has_debug_max_num_presolve_operations() const {
  bool value = (_has_bits_[1] & 0x00200000u) != 0;
  return value;
}
inline bool SatParameters::has_debug_max_num_presolve_operations() const {
  return _internal_has_debug_max_num_presolve_operations();
}
inline void SatParameters::clear_debug_max_num_presolve_operations() {
  debug_max_num_presolve_operations_ = 0;
  _has_bits_[1] &= ~0x00200000u;
}
inline int32_t SatParameters::_internal_debug_max_num_presolve_operations() const {
  return debug_max_num_presolve_operations_;
}
inline int32_t SatParameters::debug_max_num_presolve_operations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.debug_max_num_presolve_operations)
  return _internal_debug_max_num_presolve_operations();
}
inline void SatParameters::_internal_set_debug_max_num_presolve_operations(int32_t value) {
  _has_bits_[1] |= 0x00200000u;
  debug_max_num_presolve_operations_ = value;
}
inline void SatParameters::set_debug_max_num_presolve_operations(int32_t value) {
  _internal_set_debug_max_num_presolve_operations(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.debug_max_num_presolve_operations)
}
 
// optional bool debug_crash_on_bad_hint = 195 [default = false];
inline bool SatParameters::_internal_has_debug_crash_on_bad_hint() const {
  bool value = (_has_bits_[1] & 0x80000000u) != 0;
  return value;
}
inline bool SatParameters::has_debug_crash_on_bad_hint() const {
  return _internal_has_debug_crash_on_bad_hint();
}
inline void SatParameters::clear_debug_crash_on_bad_hint() {
  debug_crash_on_bad_hint_ = false;
  _has_bits_[1] &= ~0x80000000u;
}
inline bool SatParameters::_internal_debug_crash_on_bad_hint() const {
  return debug_crash_on_bad_hint_;
}
inline bool SatParameters::debug_crash_on_bad_hint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.debug_crash_on_bad_hint)
  return _internal_debug_crash_on_bad_hint();
}
inline void SatParameters::_internal_set_debug_crash_on_bad_hint(bool value) {
  _has_bits_[1] |= 0x80000000u;
  debug_crash_on_bad_hint_ = value;
}
inline void SatParameters::set_debug_crash_on_bad_hint(bool value) {
  _internal_set_debug_crash_on_bad_hint(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.debug_crash_on_bad_hint)
}
 
// optional bool use_optimization_hints = 35 [default = true];
inline bool SatParameters::_internal_has_use_optimization_hints() const {
  bool value = (_has_bits_[2] & 0x80000000u) != 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_[2] &= ~0x80000000u;
}
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_[2] |= 0x80000000u;
  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_[3] & 0x00000001u) != 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_[3] &= ~0x00000001u;
}
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_[3] |= 0x00000001u;
  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_[3] & 0x00000080u) != 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_[3] &= ~0x00000080u;
}
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_[3] |= 0x00000080u;
  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_[3] & 0x00000100u) != 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_[3] &= ~0x00000100u;
}
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_[3] |= 0x00000100u;
  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] & 0x00000080u) != 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] &= ~0x00000080u;
}
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] |= 0x00000080u;
  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] & 0x00080000u) != 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] &= ~0x00080000u;
}
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] |= 0x00080000u;
  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] & 0x00080000u) != 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] &= ~0x00080000u;
}
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] |= 0x00080000u;
  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_[3] & 0x00000200u) != 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_[3] &= ~0x00000200u;
}
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_[3] |= 0x00000200u;
  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] & 0x00100000u) != 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] &= ~0x00100000u;
}
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] |= 0x00100000u;
  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] & 0x00200000u) != 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] &= ~0x00200000u;
}
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] |= 0x00200000u;
  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] & 0x00000400u) != 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] &= ~0x00000400u;
}
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] |= 0x00000400u;
  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 bool use_cumulative_in_no_overlap_2d = 200 [default = false];
inline bool SatParameters::_internal_has_use_cumulative_in_no_overlap_2d() const {
  bool value = (_has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool SatParameters::has_use_cumulative_in_no_overlap_2d() const {
  return _internal_has_use_cumulative_in_no_overlap_2d();
}
inline void SatParameters::clear_use_cumulative_in_no_overlap_2d() {
  use_cumulative_in_no_overlap_2d_ = false;
  _has_bits_[0] &= ~0x00400000u;
}
inline bool SatParameters::_internal_use_cumulative_in_no_overlap_2d() const {
  return use_cumulative_in_no_overlap_2d_;
}
inline bool SatParameters::use_cumulative_in_no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_cumulative_in_no_overlap_2d)
  return _internal_use_cumulative_in_no_overlap_2d();
}
inline void SatParameters::_internal_set_use_cumulative_in_no_overlap_2d(bool value) {
  _has_bits_[0] |= 0x00400000u;
  use_cumulative_in_no_overlap_2d_ = value;
}
inline void SatParameters::set_use_cumulative_in_no_overlap_2d(bool value) {
  _internal_set_use_cumulative_in_no_overlap_2d(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_cumulative_in_no_overlap_2d)
}
 
// optional int32 linearization_level = 90 [default = 1];
inline bool SatParameters::_internal_has_linearization_level() const {
  bool value = (_has_bits_[3] & 0x00000800u) != 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_[3] &= ~0x00000800u;
}
inline int32_t SatParameters::_internal_linearization_level() const {
  return linearization_level_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x00000800u;
  linearization_level_ = value;
}
inline void SatParameters::set_linearization_level(int32_t 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] & 0x00100000u) != 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] &= ~0x00100000u;
}
inline int32_t SatParameters::_internal_boolean_encoding_level() const {
  return boolean_encoding_level_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x00100000u;
  boolean_encoding_level_ = value;
}
inline void SatParameters::set_boolean_encoding_level(int32_t value) {
  _internal_set_boolean_encoding_level(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.boolean_encoding_level)
}
 
// optional int32 max_domain_size_when_encoding_eq_neq_constraints = 191 [default = 16];
inline bool SatParameters::_internal_has_max_domain_size_when_encoding_eq_neq_constraints() const {
  bool value = (_has_bits_[5] & 0x00000040u) != 0;
  return value;
}
inline bool SatParameters::has_max_domain_size_when_encoding_eq_neq_constraints() const {
  return _internal_has_max_domain_size_when_encoding_eq_neq_constraints();
}
inline void SatParameters::clear_max_domain_size_when_encoding_eq_neq_constraints() {
  max_domain_size_when_encoding_eq_neq_constraints_ = 16;
  _has_bits_[5] &= ~0x00000040u;
}
inline int32_t SatParameters::_internal_max_domain_size_when_encoding_eq_neq_constraints() const {
  return max_domain_size_when_encoding_eq_neq_constraints_;
}
inline int32_t SatParameters::max_domain_size_when_encoding_eq_neq_constraints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_domain_size_when_encoding_eq_neq_constraints)
  return _internal_max_domain_size_when_encoding_eq_neq_constraints();
}
inline void SatParameters::_internal_set_max_domain_size_when_encoding_eq_neq_constraints(int32_t value) {
  _has_bits_[5] |= 0x00000040u;
  max_domain_size_when_encoding_eq_neq_constraints_ = value;
}
inline void SatParameters::set_max_domain_size_when_encoding_eq_neq_constraints(int32_t value) {
  _internal_set_max_domain_size_when_encoding_eq_neq_constraints(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_domain_size_when_encoding_eq_neq_constraints)
}
 
// optional int32 max_num_cuts = 91 [default = 10000];
inline bool SatParameters::_internal_has_max_num_cuts() const {
  bool value = (_has_bits_[3] & 0x00001000u) != 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_[3] &= ~0x00001000u;
}
inline int32_t SatParameters::_internal_max_num_cuts() const {
  return max_num_cuts_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x00001000u;
  max_num_cuts_ = value;
}
inline void SatParameters::set_max_num_cuts(int32_t value) {
  _internal_set_max_num_cuts(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_num_cuts)
}
 
// optional int32 cut_level = 196 [default = 1];
inline bool SatParameters::_internal_has_cut_level() const {
  bool value = (_has_bits_[2] & 0x00000001u) != 0;
  return value;
}
inline bool SatParameters::has_cut_level() const {
  return _internal_has_cut_level();
}
inline void SatParameters::clear_cut_level() {
  cut_level_ = 1;
  _has_bits_[2] &= ~0x00000001u;
}
inline int32_t SatParameters::_internal_cut_level() const {
  return cut_level_;
}
inline int32_t SatParameters::cut_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_level)
  return _internal_cut_level();
}
inline void SatParameters::_internal_set_cut_level(int32_t value) {
  _has_bits_[2] |= 0x00000001u;
  cut_level_ = value;
}
inline void SatParameters::set_cut_level(int32_t value) {
  _internal_set_cut_level(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_level)
}
 
// 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_[1] & 0x00800000u) != 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_[1] &= ~0x00800000u;
}
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_[1] |= 0x00800000u;
  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_objective_cut = 197 [default = false];
inline bool SatParameters::_internal_has_add_objective_cut() const {
  bool value = (_has_bits_[1] & 0x01000000u) != 0;
  return value;
}
inline bool SatParameters::has_add_objective_cut() const {
  return _internal_has_add_objective_cut();
}
inline void SatParameters::clear_add_objective_cut() {
  add_objective_cut_ = false;
  _has_bits_[1] &= ~0x01000000u;
}
inline bool SatParameters::_internal_add_objective_cut() const {
  return add_objective_cut_;
}
inline bool SatParameters::add_objective_cut() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_objective_cut)
  return _internal_add_objective_cut();
}
inline void SatParameters::_internal_set_add_objective_cut(bool value) {
  _has_bits_[1] |= 0x01000000u;
  add_objective_cut_ = value;
}
inline void SatParameters::set_add_objective_cut(bool value) {
  _internal_set_add_objective_cut(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_objective_cut)
}
 
// optional bool add_cg_cuts = 117 [default = true];
inline bool SatParameters::_internal_has_add_cg_cuts() const {
  bool value = (_has_bits_[4] & 0x00080000u) != 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_[4] &= ~0x00080000u;
}
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_[4] |= 0x00080000u;
  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_[4] & 0x00100000u) != 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_[4] &= ~0x00100000u;
}
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_[4] |= 0x00100000u;
  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 bool add_zero_half_cuts = 169 [default = true];
inline bool SatParameters::_internal_has_add_zero_half_cuts() const {
  bool value = (_has_bits_[4] & 0x00200000u) != 0;
  return value;
}
inline bool SatParameters::has_add_zero_half_cuts() const {
  return _internal_has_add_zero_half_cuts();
}
inline void SatParameters::clear_add_zero_half_cuts() {
  add_zero_half_cuts_ = true;
  _has_bits_[4] &= ~0x00200000u;
}
inline bool SatParameters::_internal_add_zero_half_cuts() const {
  return add_zero_half_cuts_;
}
inline bool SatParameters::add_zero_half_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_zero_half_cuts)
  return _internal_add_zero_half_cuts();
}
inline void SatParameters::_internal_set_add_zero_half_cuts(bool value) {
  _has_bits_[4] |= 0x00200000u;
  add_zero_half_cuts_ = value;
}
inline void SatParameters::set_add_zero_half_cuts(bool value) {
  _internal_set_add_zero_half_cuts(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_zero_half_cuts)
}
 
// optional bool add_clique_cuts = 172 [default = true];
inline bool SatParameters::_internal_has_add_clique_cuts() const {
  bool value = (_has_bits_[4] & 0x00400000u) != 0;
  return value;
}
inline bool SatParameters::has_add_clique_cuts() const {
  return _internal_has_add_clique_cuts();
}
inline void SatParameters::clear_add_clique_cuts() {
  add_clique_cuts_ = true;
  _has_bits_[4] &= ~0x00400000u;
}
inline bool SatParameters::_internal_add_clique_cuts() const {
  return add_clique_cuts_;
}
inline bool SatParameters::add_clique_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_clique_cuts)
  return _internal_add_clique_cuts();
}
inline void SatParameters::_internal_set_add_clique_cuts(bool value) {
  _has_bits_[4] |= 0x00400000u;
  add_clique_cuts_ = value;
}
inline void SatParameters::set_add_clique_cuts(bool value) {
  _internal_set_add_clique_cuts(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_clique_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] & 0x02000000u) != 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] &= ~0x02000000u;
}
inline int32_t SatParameters::_internal_max_all_diff_cut_size() const {
  return max_all_diff_cut_size_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x02000000u;
  max_all_diff_cut_size_ = value;
}
inline void SatParameters::set_max_all_diff_cut_size(int32_t 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] & 0x04000000u) != 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] &= ~0x04000000u;
}
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] |= 0x04000000u;
  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] & 0x80000000u) != 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] &= ~0x80000000u;
}
inline int32_t SatParameters::_internal_max_integer_rounding_scaling() const {
  return max_integer_rounding_scaling_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x80000000u;
  max_integer_rounding_scaling_ = value;
}
inline void SatParameters::set_max_integer_rounding_scaling(int32_t 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] & 0x08000000u) != 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] &= ~0x08000000u;
}
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] |= 0x08000000u;
  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] & 0x40000000u) != 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] &= ~0x40000000u;
}
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] |= 0x40000000u;
  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] & 0x10000000u) != 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] &= ~0x10000000u;
}
inline int32_t SatParameters::_internal_max_cut_rounds_at_level_zero() const {
  return max_cut_rounds_at_level_zero_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x10000000u;
  max_cut_rounds_at_level_zero_ = value;
}
inline void SatParameters::set_max_cut_rounds_at_level_zero(int32_t 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_[4] & 0x00000001u) != 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_[4] &= ~0x00000001u;
}
inline int32_t SatParameters::_internal_max_consecutive_inactive_count() const {
  return max_consecutive_inactive_count_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x00000001u;
  max_consecutive_inactive_count_ = value;
}
inline void SatParameters::set_max_consecutive_inactive_count(int32_t 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] & 0x08000000u) != 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] &= ~0x08000000u;
}
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] |= 0x08000000u;
  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] & 0x40000000u) != 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] &= ~0x40000000u;
}
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] |= 0x40000000u;
  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] & 0x20000000u) != 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] &= ~0x20000000u;
}
inline int32_t SatParameters::_internal_cut_cleanup_target() const {
  return cut_cleanup_target_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x20000000u;
  cut_cleanup_target_ = value;
}
inline void SatParameters::set_cut_cleanup_target(int32_t 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_[4] & 0x00000008u) != 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_[4] &= ~0x00000008u;
}
inline int32_t SatParameters::_internal_new_constraints_batch_size() const {
  return new_constraints_batch_size_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x00000008u;
  new_constraints_batch_size_ = value;
}
inline void SatParameters::set_new_constraints_batch_size(int32_t 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] & 0x00002000u) != 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] &= ~0x00002000u;
}
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] |= 0x00002000u;
  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] & 0x04000000u) != 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] &= ~0x04000000u;
}
inline int32_t SatParameters::_internal_hint_conflict_limit() const {
  return hint_conflict_limit_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x04000000u;
  hint_conflict_limit_ = value;
}
inline void SatParameters::set_hint_conflict_limit(int32_t value) {
  _internal_set_hint_conflict_limit(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.hint_conflict_limit)
}
 
// optional bool repair_hint = 167 [default = false];
inline bool SatParameters::_internal_has_repair_hint() const {
  bool value = (_has_bits_[1] & 0x02000000u) != 0;
  return value;
}
inline bool SatParameters::has_repair_hint() const {
  return _internal_has_repair_hint();
}
inline void SatParameters::clear_repair_hint() {
  repair_hint_ = false;
  _has_bits_[1] &= ~0x02000000u;
}
inline bool SatParameters::_internal_repair_hint() const {
  return repair_hint_;
}
inline bool SatParameters::repair_hint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.repair_hint)
  return _internal_repair_hint();
}
inline void SatParameters::_internal_set_repair_hint(bool value) {
  _has_bits_[1] |= 0x02000000u;
  repair_hint_ = value;
}
inline void SatParameters::set_repair_hint(bool value) {
  _internal_set_repair_hint(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.repair_hint)
}
 
// optional bool fix_variables_to_their_hinted_value = 192 [default = false];
inline bool SatParameters::_internal_has_fix_variables_to_their_hinted_value() const {
  bool value = (_has_bits_[1] & 0x04000000u) != 0;
  return value;
}
inline bool SatParameters::has_fix_variables_to_their_hinted_value() const {
  return _internal_has_fix_variables_to_their_hinted_value();
}
inline void SatParameters::clear_fix_variables_to_their_hinted_value() {
  fix_variables_to_their_hinted_value_ = false;
  _has_bits_[1] &= ~0x04000000u;
}
inline bool SatParameters::_internal_fix_variables_to_their_hinted_value() const {
  return fix_variables_to_their_hinted_value_;
}
inline bool SatParameters::fix_variables_to_their_hinted_value() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fix_variables_to_their_hinted_value)
  return _internal_fix_variables_to_their_hinted_value();
}
inline void SatParameters::_internal_set_fix_variables_to_their_hinted_value(bool value) {
  _has_bits_[1] |= 0x04000000u;
  fix_variables_to_their_hinted_value_ = value;
}
inline void SatParameters::set_fix_variables_to_their_hinted_value(bool value) {
  _internal_set_fix_variables_to_their_hinted_value(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fix_variables_to_their_hinted_value)
}
 
// optional bool exploit_integer_lp_solution = 94 [default = true];
inline bool SatParameters::_internal_has_exploit_integer_lp_solution() const {
  bool value = (_has_bits_[3] & 0x10000000u) != 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] &= ~0x10000000u;
}
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] |= 0x10000000u;
  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] & 0x20000000u) != 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] &= ~0x20000000u;
}
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] |= 0x20000000u;
  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_[1] & 0x00000100u) != 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_[1] &= ~0x00000100u;
}
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_[1] |= 0x00000100u;
  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_[1] & 0x00000200u) != 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_[1] &= ~0x00000200u;
}
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_[1] |= 0x00000200u;
  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] & 0x00400000u) != 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] &= ~0x00400000u;
}
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] |= 0x00400000u;
  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] & 0x00010000u) != 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_ = int64_t{0};
  _has_bits_[1] &= ~0x00010000u;
}
inline int64_t SatParameters::_internal_probing_period_at_root() const {
  return probing_period_at_root_;
}
inline int64_t 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(int64_t value) {
  _has_bits_[1] |= 0x00010000u;
  probing_period_at_root_ = value;
}
inline void SatParameters::set_probing_period_at_root(int64_t value) {
  _internal_set_probing_period_at_root(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.probing_period_at_root)
}
 
// optional bool use_probing_search = 176 [default = false];
inline bool SatParameters::_internal_has_use_probing_search() const {
  bool value = (_has_bits_[1] & 0x00000400u) != 0;
  return value;
}
inline bool SatParameters::has_use_probing_search() const {
  return _internal_has_use_probing_search();
}
inline void SatParameters::clear_use_probing_search() {
  use_probing_search_ = false;
  _has_bits_[1] &= ~0x00000400u;
}
inline bool SatParameters::_internal_use_probing_search() const {
  return use_probing_search_;
}
inline bool SatParameters::use_probing_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_probing_search)
  return _internal_use_probing_search();
}
inline void SatParameters::_internal_set_use_probing_search(bool value) {
  _has_bits_[1] |= 0x00000400u;
  use_probing_search_ = value;
}
inline void SatParameters::set_use_probing_search(bool value) {
  _internal_set_use_probing_search(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_probing_search)
}
 
// optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
inline bool SatParameters::_internal_has_pseudo_cost_reliability_threshold() const {
  bool value = (_has_bits_[4] & 0x00000002u) != 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_ = int64_t{100};
  _has_bits_[4] &= ~0x00000002u;
}
inline int64_t SatParameters::_internal_pseudo_cost_reliability_threshold() const {
  return pseudo_cost_reliability_threshold_;
}
inline int64_t 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(int64_t value) {
  _has_bits_[4] |= 0x00000002u;
  pseudo_cost_reliability_threshold_ = value;
}
inline void SatParameters::set_pseudo_cost_reliability_threshold(int64_t 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_[1] & 0x00000800u) != 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_[1] &= ~0x00000800u;
}
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_[1] |= 0x00000800u;
  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 bool optimize_with_lb_tree_search = 188 [default = false];
inline bool SatParameters::_internal_has_optimize_with_lb_tree_search() const {
  bool value = (_has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline bool SatParameters::has_optimize_with_lb_tree_search() const {
  return _internal_has_optimize_with_lb_tree_search();
}
inline void SatParameters::clear_optimize_with_lb_tree_search() {
  optimize_with_lb_tree_search_ = false;
  _has_bits_[1] &= ~0x00000010u;
}
inline bool SatParameters::_internal_optimize_with_lb_tree_search() const {
  return optimize_with_lb_tree_search_;
}
inline bool SatParameters::optimize_with_lb_tree_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_lb_tree_search)
  return _internal_optimize_with_lb_tree_search();
}
inline void SatParameters::_internal_set_optimize_with_lb_tree_search(bool value) {
  _has_bits_[1] |= 0x00000010u;
  optimize_with_lb_tree_search_ = value;
}
inline void SatParameters::set_optimize_with_lb_tree_search(bool value) {
  _internal_set_optimize_with_lb_tree_search(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_lb_tree_search)
}
 
// optional int32 binary_search_num_conflicts = 99 [default = -1];
inline bool SatParameters::_internal_has_binary_search_num_conflicts() const {
  bool value = (_has_bits_[3] & 0x00080000u) != 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_[3] &= ~0x00080000u;
}
inline int32_t SatParameters::_internal_binary_search_num_conflicts() const {
  return binary_search_num_conflicts_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[3] |= 0x00080000u;
  binary_search_num_conflicts_ = value;
}
inline void SatParameters::set_binary_search_num_conflicts(int32_t 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_[1] & 0x00000020u) != 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_[1] &= ~0x00000020u;
}
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_[1] |= 0x00000020u;
  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_[1] & 0x00000040u) != 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_[1] &= ~0x00000040u;
}
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_[1] |= 0x00000040u;
  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 keep_all_feasible_solutions_in_presolve = 173 [default = false];
inline bool SatParameters::_internal_has_keep_all_feasible_solutions_in_presolve() const {
  bool value = (_has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline bool SatParameters::has_keep_all_feasible_solutions_in_presolve() const {
  return _internal_has_keep_all_feasible_solutions_in_presolve();
}
inline void SatParameters::clear_keep_all_feasible_solutions_in_presolve() {
  keep_all_feasible_solutions_in_presolve_ = false;
  _has_bits_[1] &= ~0x00000080u;
}
inline bool SatParameters::_internal_keep_all_feasible_solutions_in_presolve() const {
  return keep_all_feasible_solutions_in_presolve_;
}
inline bool SatParameters::keep_all_feasible_solutions_in_presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.keep_all_feasible_solutions_in_presolve)
  return _internal_keep_all_feasible_solutions_in_presolve();
}
inline void SatParameters::_internal_set_keep_all_feasible_solutions_in_presolve(bool value) {
  _has_bits_[1] |= 0x00000080u;
  keep_all_feasible_solutions_in_presolve_ = value;
}
inline void SatParameters::set_keep_all_feasible_solutions_in_presolve(bool value) {
  _internal_set_keep_all_feasible_solutions_in_presolve(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.keep_all_feasible_solutions_in_presolve)
}
 
// 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_[1] & 0x00001000u) != 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_[1] &= ~0x00001000u;
}
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_[1] |= 0x00001000u;
  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 fill_additional_solutions_in_response = 194 [default = false];
inline bool SatParameters::_internal_has_fill_additional_solutions_in_response() const {
  bool value = (_has_bits_[1] & 0x00002000u) != 0;
  return value;
}
inline bool SatParameters::has_fill_additional_solutions_in_response() const {
  return _internal_has_fill_additional_solutions_in_response();
}
inline void SatParameters::clear_fill_additional_solutions_in_response() {
  fill_additional_solutions_in_response_ = false;
  _has_bits_[1] &= ~0x00002000u;
}
inline bool SatParameters::_internal_fill_additional_solutions_in_response() const {
  return fill_additional_solutions_in_response_;
}
inline bool SatParameters::fill_additional_solutions_in_response() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fill_additional_solutions_in_response)
  return _internal_fill_additional_solutions_in_response();
}
inline void SatParameters::_internal_set_fill_additional_solutions_in_response(bool value) {
  _has_bits_[1] |= 0x00002000u;
  fill_additional_solutions_in_response_ = value;
}
inline void SatParameters::set_fill_additional_solutions_in_response(bool value) {
  _internal_set_fill_additional_solutions_in_response(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fill_additional_solutions_in_response)
}
 
// optional bool instantiate_all_variables = 106 [default = true];
inline bool SatParameters::_internal_has_instantiate_all_variables() const {
  bool value = (_has_bits_[3] & 0x00800000u) != 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] &= ~0x00800000u;
}
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] |= 0x00800000u;
  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] & 0x01000000u) != 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] &= ~0x01000000u;
}
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] |= 0x01000000u;
  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_[1] & 0x00004000u) != 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_[1] &= ~0x00004000u;
}
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_[1] |= 0x00004000u;
  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] & 0x00008000u) != 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] &= ~0x00008000u;
}
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] |= 0x00008000u;
  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 = 0];
inline bool SatParameters::_internal_has_num_search_workers() const {
  bool value = (_has_bits_[0] & 0x00040000u) != 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_ = 0;
  _has_bits_[0] &= ~0x00040000u;
}
inline int32_t SatParameters::_internal_num_search_workers() const {
  return num_search_workers_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[0] |= 0x00040000u;
  num_search_workers_ = value;
}
inline void SatParameters::set_num_search_workers(int32_t 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] & 0x00000001u) != 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] &= ~0x00000001u;
}
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] |= 0x00000001u;
  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] & 0x00001000u) != 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] &= ~0x00001000u;
}
inline int32_t SatParameters::_internal_interleave_batch_size() const {
  return interleave_batch_size_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x00001000u;
  interleave_batch_size_ = value;
}
inline void SatParameters::set_interleave_batch_size(int32_t 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] & 0x00000002u) != 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] &= ~0x00000002u;
}
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] |= 0x00000002u;
  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] & 0x02000000u) != 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] &= ~0x02000000u;
}
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] |= 0x02000000u;
  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_[4] & 0x00000100u) != 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_[4] &= ~0x00000100u;
}
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_[4] |= 0x00000100u;
  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] & 0x00000004u) != 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] &= ~0x00000004u;
}
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] |= 0x00000004u;
  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 int32 solution_pool_size = 193 [default = 3];
inline bool SatParameters::_internal_has_solution_pool_size() const {
  bool value = (_has_bits_[5] & 0x00000080u) != 0;
  return value;
}
inline bool SatParameters::has_solution_pool_size() const {
  return _internal_has_solution_pool_size();
}
inline void SatParameters::clear_solution_pool_size() {
  solution_pool_size_ = 3;
  _has_bits_[5] &= ~0x00000080u;
}
inline int32_t SatParameters::_internal_solution_pool_size() const {
  return solution_pool_size_;
}
inline int32_t SatParameters::solution_pool_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.solution_pool_size)
  return _internal_solution_pool_size();
}
inline void SatParameters::_internal_set_solution_pool_size(int32_t value) {
  _has_bits_[5] |= 0x00000080u;
  solution_pool_size_ = value;
}
inline void SatParameters::set_solution_pool_size(int32_t value) {
  _internal_set_solution_pool_size(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.solution_pool_size)
}
 
// optional bool use_rins_lns = 129 [default = true];
inline bool SatParameters::_internal_has_use_rins_lns() const {
  bool value = (_has_bits_[4] & 0x00000200u) != 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_[4] &= ~0x00000200u;
}
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_[4] |= 0x00000200u;
  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_[4] & 0x00000400u) != 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_[4] &= ~0x00000400u;
}
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_[4] |= 0x00000400u;
  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_[5] & 0x00000001u) != 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_[5] &= ~0x00000001u;
}
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_[5] |= 0x00000001u;
  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] & 0x00000008u) != 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] &= ~0x00000008u;
}
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] |= 0x00000008u;
  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_[0] & 0x10000000u) != 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_[0] &= ~0x10000000u;
}
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_[0] |= 0x10000000u;
  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_[0] & 0x20000000u) != 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_[0] &= ~0x20000000u;
}
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_[0] |= 0x20000000u;
  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] & 0x00800000u) != 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_ = int64_t{0};
  _has_bits_[0] &= ~0x00800000u;
}
inline int64_t SatParameters::_internal_search_randomization_tolerance() const {
  return search_randomization_tolerance_;
}
inline int64_t 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(int64_t value) {
  _has_bits_[0] |= 0x00800000u;
  search_randomization_tolerance_ = value;
}
inline void SatParameters::set_search_randomization_tolerance(int64_t 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_[4] & 0x00000800u) != 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_[4] &= ~0x00000800u;
}
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_[4] |= 0x00000800u;
  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_[4] & 0x00004000u) != 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_[4] &= ~0x00004000u;
}
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_[4] |= 0x00004000u;
  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_[0] & 0x40000000u) != 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_[0] &= ~0x40000000u;
}
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_[0] |= 0x40000000u;
  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_[0] & 0x80000000u) != 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_[0] &= ~0x80000000u;
}
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_[0] |= 0x80000000u;
  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] & 0x00008000u) != 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] &= ~0x00008000u;
}
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] |= 0x00008000u;
  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] & 0x00010000u) != 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] &= ~0x00010000u;
}
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] |= 0x00010000u;
  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 bool polish_lp_solution = 175 [default = false];
inline bool SatParameters::_internal_has_polish_lp_solution() const {
  bool value = (_has_bits_[1] & 0x08000000u) != 0;
  return value;
}
inline bool SatParameters::has_polish_lp_solution() const {
  return _internal_has_polish_lp_solution();
}
inline void SatParameters::clear_polish_lp_solution() {
  polish_lp_solution_ = false;
  _has_bits_[1] &= ~0x08000000u;
}
inline bool SatParameters::_internal_polish_lp_solution() const {
  return polish_lp_solution_;
}
inline bool SatParameters::polish_lp_solution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.polish_lp_solution)
  return _internal_polish_lp_solution();
}
inline void SatParameters::_internal_set_polish_lp_solution(bool value) {
  _has_bits_[1] |= 0x08000000u;
  polish_lp_solution_ = value;
}
inline void SatParameters::set_polish_lp_solution(bool value) {
  _internal_set_polish_lp_solution(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.polish_lp_solution)
}
 
// optional bool convert_intervals = 177 [default = true];
inline bool SatParameters::_internal_has_convert_intervals() const {
  bool value = (_has_bits_[4] & 0x00020000u) != 0;
  return value;
}
inline bool SatParameters::has_convert_intervals() const {
  return _internal_has_convert_intervals();
}
inline void SatParameters::clear_convert_intervals() {
  convert_intervals_ = true;
  _has_bits_[4] &= ~0x00020000u;
}
inline bool SatParameters::_internal_convert_intervals() const {
  return convert_intervals_;
}
inline bool SatParameters::convert_intervals() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.convert_intervals)
  return _internal_convert_intervals();
}
inline void SatParameters::_internal_set_convert_intervals(bool value) {
  _has_bits_[4] |= 0x00020000u;
  convert_intervals_ = value;
}
inline void SatParameters::set_convert_intervals(bool value) {
  _internal_set_convert_intervals(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.convert_intervals)
}
 
// optional int32 symmetry_level = 183 [default = 2];
inline bool SatParameters::_internal_has_symmetry_level() const {
  bool value = (_has_bits_[5] & 0x00000010u) != 0;
  return value;
}
inline bool SatParameters::has_symmetry_level() const {
  return _internal_has_symmetry_level();
}
inline void SatParameters::clear_symmetry_level() {
  symmetry_level_ = 2;
  _has_bits_[5] &= ~0x00000010u;
}
inline int32_t SatParameters::_internal_symmetry_level() const {
  return symmetry_level_;
}
inline int32_t SatParameters::symmetry_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.symmetry_level)
  return _internal_symmetry_level();
}
inline void SatParameters::_internal_set_symmetry_level(int32_t value) {
  _has_bits_[5] |= 0x00000010u;
  symmetry_level_ = value;
}
inline void SatParameters::set_symmetry_level(int32_t value) {
  _internal_set_symmetry_level(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.symmetry_level)
}
 
// optional double mip_max_bound = 124 [default = 10000000];
inline bool SatParameters::_internal_has_mip_max_bound() const {
  bool value = (_has_bits_[4] & 0x00000004u) != 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_[4] &= ~0x00000004u;
}
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_[4] |= 0x00000004u;
  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_[4] & 0x00000020u) != 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_[4] &= ~0x00000020u;
}
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_[4] |= 0x00000020u;
  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_[5] & 0x00000004u) != 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_[5] &= ~0x00000004u;
}
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_[5] |= 0x00000004u;
  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_[4] & 0x00000040u) != 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_[4] &= ~0x00000040u;
}
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_[4] |= 0x00000040u;
  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_[4] & 0x00000010u) != 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_[4] &= ~0x00000010u;
}
inline int32_t SatParameters::_internal_mip_max_activity_exponent() const {
  return mip_max_activity_exponent_;
}
inline int32_t 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(int32_t value) {
  _has_bits_[4] |= 0x00000010u;
  mip_max_activity_exponent_ = value;
}
inline void SatParameters::set_mip_max_activity_exponent(int32_t 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_[4] & 0x00000080u) != 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_[4] &= ~0x00000080u;
}
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_[4] |= 0x00000080u;
  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)
}
 
// optional bool mip_compute_true_objective_bound = 198 [default = true];
inline bool SatParameters::_internal_has_mip_compute_true_objective_bound() const {
  bool value = (_has_bits_[5] & 0x00000008u) != 0;
  return value;
}
inline bool SatParameters::has_mip_compute_true_objective_bound() const {
  return _internal_has_mip_compute_true_objective_bound();
}
inline void SatParameters::clear_mip_compute_true_objective_bound() {
  mip_compute_true_objective_bound_ = true;
  _has_bits_[5] &= ~0x00000008u;
}
inline bool SatParameters::_internal_mip_compute_true_objective_bound() const {
  return mip_compute_true_objective_bound_;
}
inline bool SatParameters::mip_compute_true_objective_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_compute_true_objective_bound)
  return _internal_mip_compute_true_objective_bound();
}
inline void SatParameters::_internal_set_mip_compute_true_objective_bound(bool value) {
  _has_bits_[5] |= 0x00000008u;
  mip_compute_true_objective_bound_ = value;
}
inline void SatParameters::set_mip_compute_true_objective_bound(bool value) {
  _internal_set_mip_compute_true_objective_bound(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_compute_true_objective_bound)
}
 
// optional double mip_max_valid_magnitude = 199 [default = 1e+30];
inline bool SatParameters::_internal_has_mip_max_valid_magnitude() const {
  bool value = (_has_bits_[5] & 0x00000100u) != 0;
  return value;
}
inline bool SatParameters::has_mip_max_valid_magnitude() const {
  return _internal_has_mip_max_valid_magnitude();
}
inline void SatParameters::clear_mip_max_valid_magnitude() {
  mip_max_valid_magnitude_ = 1e+30;
  _has_bits_[5] &= ~0x00000100u;
}
inline double SatParameters::_internal_mip_max_valid_magnitude() const {
  return mip_max_valid_magnitude_;
}
inline double SatParameters::mip_max_valid_magnitude() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_max_valid_magnitude)
  return _internal_mip_max_valid_magnitude();
}
inline void SatParameters::_internal_set_mip_max_valid_magnitude(double value) {
  _has_bits_[5] |= 0x00000100u;
  mip_max_valid_magnitude_ = value;
}
inline void SatParameters::set_mip_max_valid_magnitude(double value) {
  _internal_set_mip_max_valid_magnitude(value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_valid_magnitude)
}
 
#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