sat_parameters.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: ortools/sat/sat_parameters.proto
// Protobuf C++ Version: 6.33.1
 
#ifndef ortools_2fsat_2fsat_5fparameters_2eproto_2epb_2eh
#define ortools_2fsat_2fsat_5fparameters_2eproto_2epb_2eh
 
#include <limits>
#include <string>
#include <type_traits>
#include <utility>
 
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 6033001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.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/message_lite.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)
 
// Must be included last.
#include "google/protobuf/port_def.inc"
 
#define PROTOBUF_INTERNAL_EXPORT_ortools_2fsat_2fsat_5fparameters_2eproto OR_PROTO_DLL
 
namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google
 
// Internal implementation detail -- do not use these members.
struct OR_PROTO_DLL TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
OR_PROTO_DLL extern const ::google::protobuf::internal::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto;
}  // extern "C"
namespace operations_research {
namespace sat {
enum SatParameters_BinaryMinizationAlgorithm : int;
OR_PROTO_DLL extern const uint32_t SatParameters_BinaryMinizationAlgorithm_internal_data_[];
enum SatParameters_ClauseOrdering : int;
OR_PROTO_DLL extern const uint32_t SatParameters_ClauseOrdering_internal_data_[];
enum SatParameters_ConflictMinimizationAlgorithm : int;
OR_PROTO_DLL extern const uint32_t SatParameters_ConflictMinimizationAlgorithm_internal_data_[];
enum SatParameters_FPRoundingMethod : int;
OR_PROTO_DLL extern const uint32_t SatParameters_FPRoundingMethod_internal_data_[];
enum SatParameters_MaxSatAssumptionOrder : int;
OR_PROTO_DLL extern const uint32_t SatParameters_MaxSatAssumptionOrder_internal_data_[];
enum SatParameters_MaxSatStratificationAlgorithm : int;
OR_PROTO_DLL extern const uint32_t SatParameters_MaxSatStratificationAlgorithm_internal_data_[];
enum SatParameters_Polarity : int;
OR_PROTO_DLL extern const uint32_t SatParameters_Polarity_internal_data_[];
enum SatParameters_RestartAlgorithm : int;
OR_PROTO_DLL extern const uint32_t SatParameters_RestartAlgorithm_internal_data_[];
enum SatParameters_SearchBranching : int;
OR_PROTO_DLL extern const uint32_t SatParameters_SearchBranching_internal_data_[];
enum SatParameters_SharedTreeSplitStrategy : int;
OR_PROTO_DLL extern const uint32_t SatParameters_SharedTreeSplitStrategy_internal_data_[];
enum SatParameters_VariableOrder : int;
OR_PROTO_DLL extern const uint32_t SatParameters_VariableOrder_internal_data_[];
class SatParameters;
struct SatParametersDefaultTypeInternal;
OR_PROTO_DLL extern SatParametersDefaultTypeInternal _SatParameters_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SatParameters_class_data_;
}  // namespace sat
}  // namespace operations_research
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_BinaryMinizationAlgorithm>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_ClauseOrdering_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_ClauseOrdering>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_FPRoundingMethod_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_FPRoundingMethod>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_MaxSatAssumptionOrder_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_MaxSatAssumptionOrder>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_Polarity_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_Polarity>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_RestartAlgorithm_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_RestartAlgorithm>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_SearchBranching_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_SearchBranching>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_SharedTreeSplitStrategy_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_SharedTreeSplitStrategy>;
template <>
internal::EnumTraitsT<::operations_research::sat::SatParameters_VariableOrder_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::sat::SatParameters_VariableOrder>;
}  // namespace protobuf
}  // namespace google
 
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,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_VariableOrder_internal_data_[];
inline constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MIN =
    static_cast<SatParameters_VariableOrder>(0);
inline constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MAX =
    static_cast<SatParameters_VariableOrder>(2);
inline bool SatParameters_VariableOrder_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int SatParameters_VariableOrder_VariableOrder_ARRAYSIZE = 2 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_VariableOrder_descriptor();
template <typename T>
const ::std::string& SatParameters_VariableOrder_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_VariableOrder>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to VariableOrder_Name().");
  return SatParameters_VariableOrder_Name(static_cast<SatParameters_VariableOrder>(value));
}
template <>
inline const ::std::string& SatParameters_VariableOrder_Name(SatParameters_VariableOrder value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_VariableOrder_descriptor, 0, 2>(
      static_cast<int>(value));
}
inline bool SatParameters_VariableOrder_Parse(
    ::absl::string_view name, SatParameters_VariableOrder* PROTOBUF_NONNULL value) {
  return ::google::protobuf::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,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_Polarity_internal_data_[];
inline constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MIN =
    static_cast<SatParameters_Polarity>(0);
inline constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MAX =
    static_cast<SatParameters_Polarity>(2);
inline bool SatParameters_Polarity_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int SatParameters_Polarity_Polarity_ARRAYSIZE = 2 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_Polarity_descriptor();
template <typename T>
const ::std::string& SatParameters_Polarity_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_Polarity>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Polarity_Name().");
  return SatParameters_Polarity_Name(static_cast<SatParameters_Polarity>(value));
}
template <>
inline const ::std::string& SatParameters_Polarity_Name(SatParameters_Polarity value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_Polarity_descriptor, 0, 2>(
      static_cast<int>(value));
}
inline bool SatParameters_Polarity_Parse(
    ::absl::string_view name, SatParameters_Polarity* PROTOBUF_NONNULL value) {
  return ::google::protobuf::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,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_ConflictMinimizationAlgorithm_internal_data_[];
inline constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN =
    static_cast<SatParameters_ConflictMinimizationAlgorithm>(0);
inline constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX =
    static_cast<SatParameters_ConflictMinimizationAlgorithm>(2);
inline bool SatParameters_ConflictMinimizationAlgorithm_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE = 2 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_ConflictMinimizationAlgorithm_descriptor();
template <typename T>
const ::std::string& SatParameters_ConflictMinimizationAlgorithm_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_ConflictMinimizationAlgorithm>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to ConflictMinimizationAlgorithm_Name().");
  return SatParameters_ConflictMinimizationAlgorithm_Name(static_cast<SatParameters_ConflictMinimizationAlgorithm>(value));
}
template <>
inline const ::std::string& SatParameters_ConflictMinimizationAlgorithm_Name(SatParameters_ConflictMinimizationAlgorithm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_ConflictMinimizationAlgorithm_descriptor, 0, 2>(
      static_cast<int>(value));
}
inline bool SatParameters_ConflictMinimizationAlgorithm_Parse(
    ::absl::string_view name, SatParameters_ConflictMinimizationAlgorithm* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<SatParameters_ConflictMinimizationAlgorithm>(SatParameters_ConflictMinimizationAlgorithm_descriptor(), name,
                                           value);
}
enum SatParameters_BinaryMinizationAlgorithm : int {
  SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION = 0,
  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FROM_UIP = 1,
  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS = 5,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_BinaryMinizationAlgorithm_internal_data_[];
inline constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN =
    static_cast<SatParameters_BinaryMinizationAlgorithm>(0);
inline constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX =
    static_cast<SatParameters_BinaryMinizationAlgorithm>(5);
inline bool SatParameters_BinaryMinizationAlgorithm_IsValid(int value) {
  return 0 <= value && value <= 5 && ((35u >> value) & 1) != 0;
}
inline constexpr int SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE = 5 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_BinaryMinizationAlgorithm_descriptor();
template <typename T>
const ::std::string& SatParameters_BinaryMinizationAlgorithm_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_BinaryMinizationAlgorithm>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to BinaryMinizationAlgorithm_Name().");
  return SatParameters_BinaryMinizationAlgorithm_Name(static_cast<SatParameters_BinaryMinizationAlgorithm>(value));
}
template <>
inline const ::std::string& SatParameters_BinaryMinizationAlgorithm_Name(SatParameters_BinaryMinizationAlgorithm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_BinaryMinizationAlgorithm_descriptor, 0, 5>(
      static_cast<int>(value));
}
inline bool SatParameters_BinaryMinizationAlgorithm_Parse(
    ::absl::string_view name, SatParameters_BinaryMinizationAlgorithm* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<SatParameters_BinaryMinizationAlgorithm>(SatParameters_BinaryMinizationAlgorithm_descriptor(), name,
                                           value);
}
enum SatParameters_ClauseOrdering : int {
  SatParameters_ClauseOrdering_CLAUSE_ACTIVITY = 0,
  SatParameters_ClauseOrdering_CLAUSE_LBD = 1,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_ClauseOrdering_internal_data_[];
inline constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MIN =
    static_cast<SatParameters_ClauseOrdering>(0);
inline constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MAX =
    static_cast<SatParameters_ClauseOrdering>(1);
inline bool SatParameters_ClauseOrdering_IsValid(int value) {
  return 0 <= value && value <= 1;
}
inline constexpr int SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE = 1 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_ClauseOrdering_descriptor();
template <typename T>
const ::std::string& SatParameters_ClauseOrdering_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_ClauseOrdering>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to ClauseOrdering_Name().");
  return SatParameters_ClauseOrdering_Name(static_cast<SatParameters_ClauseOrdering>(value));
}
template <>
inline const ::std::string& SatParameters_ClauseOrdering_Name(SatParameters_ClauseOrdering value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_ClauseOrdering_descriptor, 0, 1>(
      static_cast<int>(value));
}
inline bool SatParameters_ClauseOrdering_Parse(
    ::absl::string_view name, SatParameters_ClauseOrdering* PROTOBUF_NONNULL value) {
  return ::google::protobuf::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,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_RestartAlgorithm_internal_data_[];
inline constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MIN =
    static_cast<SatParameters_RestartAlgorithm>(0);
inline constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MAX =
    static_cast<SatParameters_RestartAlgorithm>(4);
inline bool SatParameters_RestartAlgorithm_IsValid(int value) {
  return 0 <= value && value <= 4;
}
inline constexpr int SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE = 4 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_RestartAlgorithm_descriptor();
template <typename T>
const ::std::string& SatParameters_RestartAlgorithm_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_RestartAlgorithm>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to RestartAlgorithm_Name().");
  return SatParameters_RestartAlgorithm_Name(static_cast<SatParameters_RestartAlgorithm>(value));
}
template <>
inline const ::std::string& SatParameters_RestartAlgorithm_Name(SatParameters_RestartAlgorithm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_RestartAlgorithm_descriptor, 0, 4>(
      static_cast<int>(value));
}
inline bool SatParameters_RestartAlgorithm_Parse(
    ::absl::string_view name, SatParameters_RestartAlgorithm* PROTOBUF_NONNULL value) {
  return ::google::protobuf::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,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_MaxSatAssumptionOrder_internal_data_[];
inline constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN =
    static_cast<SatParameters_MaxSatAssumptionOrder>(0);
inline constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX =
    static_cast<SatParameters_MaxSatAssumptionOrder>(2);
inline bool SatParameters_MaxSatAssumptionOrder_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE = 2 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_MaxSatAssumptionOrder_descriptor();
template <typename T>
const ::std::string& SatParameters_MaxSatAssumptionOrder_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_MaxSatAssumptionOrder>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to MaxSatAssumptionOrder_Name().");
  return SatParameters_MaxSatAssumptionOrder_Name(static_cast<SatParameters_MaxSatAssumptionOrder>(value));
}
template <>
inline const ::std::string& SatParameters_MaxSatAssumptionOrder_Name(SatParameters_MaxSatAssumptionOrder value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_MaxSatAssumptionOrder_descriptor, 0, 2>(
      static_cast<int>(value));
}
inline bool SatParameters_MaxSatAssumptionOrder_Parse(
    ::absl::string_view name, SatParameters_MaxSatAssumptionOrder* PROTOBUF_NONNULL value) {
  return ::google::protobuf::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,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_MaxSatStratificationAlgorithm_internal_data_[];
inline constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN =
    static_cast<SatParameters_MaxSatStratificationAlgorithm>(0);
inline constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX =
    static_cast<SatParameters_MaxSatStratificationAlgorithm>(2);
inline bool SatParameters_MaxSatStratificationAlgorithm_IsValid(int value) {
  return 0 <= value && value <= 2;
}
inline constexpr int SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE = 2 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_MaxSatStratificationAlgorithm_descriptor();
template <typename T>
const ::std::string& SatParameters_MaxSatStratificationAlgorithm_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_MaxSatStratificationAlgorithm>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to MaxSatStratificationAlgorithm_Name().");
  return SatParameters_MaxSatStratificationAlgorithm_Name(static_cast<SatParameters_MaxSatStratificationAlgorithm>(value));
}
template <>
inline const ::std::string& SatParameters_MaxSatStratificationAlgorithm_Name(SatParameters_MaxSatStratificationAlgorithm value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_MaxSatStratificationAlgorithm_descriptor, 0, 2>(
      static_cast<int>(value));
}
inline bool SatParameters_MaxSatStratificationAlgorithm_Parse(
    ::absl::string_view name, SatParameters_MaxSatStratificationAlgorithm* PROTOBUF_NONNULL value) {
  return ::google::protobuf::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,
  SatParameters_SearchBranching_PARTIAL_FIXED_SEARCH = 7,
  SatParameters_SearchBranching_RANDOMIZED_SEARCH = 8,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_SearchBranching_internal_data_[];
inline constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MIN =
    static_cast<SatParameters_SearchBranching>(0);
inline constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MAX =
    static_cast<SatParameters_SearchBranching>(8);
inline bool SatParameters_SearchBranching_IsValid(int value) {
  return 0 <= value && value <= 8;
}
inline constexpr int SatParameters_SearchBranching_SearchBranching_ARRAYSIZE = 8 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_SearchBranching_descriptor();
template <typename T>
const ::std::string& SatParameters_SearchBranching_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_SearchBranching>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to SearchBranching_Name().");
  return SatParameters_SearchBranching_Name(static_cast<SatParameters_SearchBranching>(value));
}
template <>
inline const ::std::string& SatParameters_SearchBranching_Name(SatParameters_SearchBranching value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_SearchBranching_descriptor, 0, 8>(
      static_cast<int>(value));
}
inline bool SatParameters_SearchBranching_Parse(
    ::absl::string_view name, SatParameters_SearchBranching* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<SatParameters_SearchBranching>(SatParameters_SearchBranching_descriptor(), name,
                                           value);
}
enum SatParameters_SharedTreeSplitStrategy : int {
  SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_AUTO = 0,
  SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_DISCREPANCY = 1,
  SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_OBJECTIVE_LB = 2,
  SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_BALANCED_TREE = 3,
  SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_FIRST_PROPOSAL = 4,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_SharedTreeSplitStrategy_internal_data_[];
inline constexpr SatParameters_SharedTreeSplitStrategy SatParameters_SharedTreeSplitStrategy_SharedTreeSplitStrategy_MIN =
    static_cast<SatParameters_SharedTreeSplitStrategy>(0);
inline constexpr SatParameters_SharedTreeSplitStrategy SatParameters_SharedTreeSplitStrategy_SharedTreeSplitStrategy_MAX =
    static_cast<SatParameters_SharedTreeSplitStrategy>(4);
inline bool SatParameters_SharedTreeSplitStrategy_IsValid(int value) {
  return 0 <= value && value <= 4;
}
inline constexpr int SatParameters_SharedTreeSplitStrategy_SharedTreeSplitStrategy_ARRAYSIZE = 4 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_SharedTreeSplitStrategy_descriptor();
template <typename T>
const ::std::string& SatParameters_SharedTreeSplitStrategy_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_SharedTreeSplitStrategy>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to SharedTreeSplitStrategy_Name().");
  return SatParameters_SharedTreeSplitStrategy_Name(static_cast<SatParameters_SharedTreeSplitStrategy>(value));
}
template <>
inline const ::std::string& SatParameters_SharedTreeSplitStrategy_Name(SatParameters_SharedTreeSplitStrategy value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_SharedTreeSplitStrategy_descriptor, 0, 4>(
      static_cast<int>(value));
}
inline bool SatParameters_SharedTreeSplitStrategy_Parse(
    ::absl::string_view name, SatParameters_SharedTreeSplitStrategy* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<SatParameters_SharedTreeSplitStrategy>(SatParameters_SharedTreeSplitStrategy_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,
};
 
OR_PROTO_DLL extern const uint32_t SatParameters_FPRoundingMethod_internal_data_[];
inline constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MIN =
    static_cast<SatParameters_FPRoundingMethod>(0);
inline constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MAX =
    static_cast<SatParameters_FPRoundingMethod>(3);
inline bool SatParameters_FPRoundingMethod_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE = 3 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SatParameters_FPRoundingMethod_descriptor();
template <typename T>
const ::std::string& SatParameters_FPRoundingMethod_Name(T value) {
  static_assert(::std::is_same<T, SatParameters_FPRoundingMethod>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to FPRoundingMethod_Name().");
  return SatParameters_FPRoundingMethod_Name(static_cast<SatParameters_FPRoundingMethod>(value));
}
template <>
inline const ::std::string& SatParameters_FPRoundingMethod_Name(SatParameters_FPRoundingMethod value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SatParameters_FPRoundingMethod_descriptor, 0, 3>(
      static_cast<int>(value));
}
inline bool SatParameters_FPRoundingMethod_Parse(
    ::absl::string_view name, SatParameters_FPRoundingMethod* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<SatParameters_FPRoundingMethod>(SatParameters_FPRoundingMethod_descriptor(), name,
                                           value);
}
 
// ===================================================================
 
 
// -------------------------------------------------------------------
 
class OR_PROTO_DLL SatParameters final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.sat.SatParameters) */ {
 public:
  inline SatParameters() : SatParameters(nullptr) {}
  ~SatParameters() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SatParameters* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SatParameters));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR SatParameters(::google::protobuf::internal::ConstantInitialized);
 
  inline SatParameters(const SatParameters& from) : SatParameters(nullptr, from) {}
  inline SatParameters(SatParameters&& from) noexcept
      : SatParameters(nullptr, ::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 (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }
 
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SatParameters& 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* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SatParameters* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SatParameters* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SatParameters>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SatParameters& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SatParameters& from) { SatParameters::MergeImpl(*this, from); }
 
  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);
 
  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
 
  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SatParameters* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "operations_research.sat.SatParameters"; }
 
  explicit SatParameters(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SatParameters(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SatParameters& from);
  SatParameters(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SatParameters&& from) noexcept
      : SatParameters(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();
 
 public:
  static constexpr auto InternalGenerateClassData_();
 
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
  using VariableOrder = SatParameters_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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL VariableOrder_descriptor() {
    return SatParameters_VariableOrder_descriptor();
  }
  template <typename T>
  static inline const ::std::string& VariableOrder_Name(T value) {
    return SatParameters_VariableOrder_Name(value);
  }
  static inline bool VariableOrder_Parse(
      ::absl::string_view name, VariableOrder* PROTOBUF_NONNULL value) {
    return SatParameters_VariableOrder_Parse(name, value);
  }
  using Polarity = SatParameters_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 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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Polarity_descriptor() {
    return SatParameters_Polarity_descriptor();
  }
  template <typename T>
  static inline const ::std::string& Polarity_Name(T value) {
    return SatParameters_Polarity_Name(value);
  }
  static inline bool Polarity_Parse(
      ::absl::string_view name, Polarity* PROTOBUF_NONNULL value) {
    return SatParameters_Polarity_Parse(name, value);
  }
  using ConflictMinimizationAlgorithm = SatParameters_ConflictMinimizationAlgorithm;
  static constexpr ConflictMinimizationAlgorithm NONE = SatParameters_ConflictMinimizationAlgorithm_NONE;
  static constexpr ConflictMinimizationAlgorithm SIMPLE = SatParameters_ConflictMinimizationAlgorithm_SIMPLE;
  static constexpr ConflictMinimizationAlgorithm RECURSIVE = SatParameters_ConflictMinimizationAlgorithm_RECURSIVE;
  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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ConflictMinimizationAlgorithm_descriptor() {
    return SatParameters_ConflictMinimizationAlgorithm_descriptor();
  }
  template <typename T>
  static inline const ::std::string& ConflictMinimizationAlgorithm_Name(T value) {
    return SatParameters_ConflictMinimizationAlgorithm_Name(value);
  }
  static inline bool ConflictMinimizationAlgorithm_Parse(
      ::absl::string_view name, ConflictMinimizationAlgorithm* PROTOBUF_NONNULL value) {
    return SatParameters_ConflictMinimizationAlgorithm_Parse(name, value);
  }
  using BinaryMinizationAlgorithm = SatParameters_BinaryMinizationAlgorithm;
  static constexpr BinaryMinizationAlgorithm NO_BINARY_MINIMIZATION = SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION;
  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_FROM_UIP = SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FROM_UIP;
  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS = SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS;
  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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL BinaryMinizationAlgorithm_descriptor() {
    return SatParameters_BinaryMinizationAlgorithm_descriptor();
  }
  template <typename T>
  static inline const ::std::string& BinaryMinizationAlgorithm_Name(T value) {
    return SatParameters_BinaryMinizationAlgorithm_Name(value);
  }
  static inline bool BinaryMinizationAlgorithm_Parse(
      ::absl::string_view name, BinaryMinizationAlgorithm* PROTOBUF_NONNULL value) {
    return SatParameters_BinaryMinizationAlgorithm_Parse(name, value);
  }
  using ClauseOrdering = SatParameters_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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ClauseOrdering_descriptor() {
    return SatParameters_ClauseOrdering_descriptor();
  }
  template <typename T>
  static inline const ::std::string& ClauseOrdering_Name(T value) {
    return SatParameters_ClauseOrdering_Name(value);
  }
  static inline bool ClauseOrdering_Parse(
      ::absl::string_view name, ClauseOrdering* PROTOBUF_NONNULL value) {
    return SatParameters_ClauseOrdering_Parse(name, value);
  }
  using RestartAlgorithm = SatParameters_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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RestartAlgorithm_descriptor() {
    return SatParameters_RestartAlgorithm_descriptor();
  }
  template <typename T>
  static inline const ::std::string& RestartAlgorithm_Name(T value) {
    return SatParameters_RestartAlgorithm_Name(value);
  }
  static inline bool RestartAlgorithm_Parse(
      ::absl::string_view name, RestartAlgorithm* PROTOBUF_NONNULL value) {
    return SatParameters_RestartAlgorithm_Parse(name, value);
  }
  using MaxSatAssumptionOrder = SatParameters_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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL MaxSatAssumptionOrder_descriptor() {
    return SatParameters_MaxSatAssumptionOrder_descriptor();
  }
  template <typename T>
  static inline const ::std::string& MaxSatAssumptionOrder_Name(T value) {
    return SatParameters_MaxSatAssumptionOrder_Name(value);
  }
  static inline bool MaxSatAssumptionOrder_Parse(
      ::absl::string_view name, MaxSatAssumptionOrder* PROTOBUF_NONNULL value) {
    return SatParameters_MaxSatAssumptionOrder_Parse(name, value);
  }
  using MaxSatStratificationAlgorithm = SatParameters_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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL MaxSatStratificationAlgorithm_descriptor() {
    return SatParameters_MaxSatStratificationAlgorithm_descriptor();
  }
  template <typename T>
  static inline const ::std::string& MaxSatStratificationAlgorithm_Name(T value) {
    return SatParameters_MaxSatStratificationAlgorithm_Name(value);
  }
  static inline bool MaxSatStratificationAlgorithm_Parse(
      ::absl::string_view name, MaxSatStratificationAlgorithm* PROTOBUF_NONNULL value) {
    return SatParameters_MaxSatStratificationAlgorithm_Parse(name, value);
  }
  using SearchBranching = SatParameters_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 constexpr SearchBranching PARTIAL_FIXED_SEARCH = SatParameters_SearchBranching_PARTIAL_FIXED_SEARCH;
  static constexpr SearchBranching RANDOMIZED_SEARCH = SatParameters_SearchBranching_RANDOMIZED_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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SearchBranching_descriptor() {
    return SatParameters_SearchBranching_descriptor();
  }
  template <typename T>
  static inline const ::std::string& SearchBranching_Name(T value) {
    return SatParameters_SearchBranching_Name(value);
  }
  static inline bool SearchBranching_Parse(
      ::absl::string_view name, SearchBranching* PROTOBUF_NONNULL value) {
    return SatParameters_SearchBranching_Parse(name, value);
  }
  using SharedTreeSplitStrategy = SatParameters_SharedTreeSplitStrategy;
  static constexpr SharedTreeSplitStrategy SPLIT_STRATEGY_AUTO = SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_AUTO;
  static constexpr SharedTreeSplitStrategy SPLIT_STRATEGY_DISCREPANCY = SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_DISCREPANCY;
  static constexpr SharedTreeSplitStrategy SPLIT_STRATEGY_OBJECTIVE_LB = SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_OBJECTIVE_LB;
  static constexpr SharedTreeSplitStrategy SPLIT_STRATEGY_BALANCED_TREE = SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_BALANCED_TREE;
  static constexpr SharedTreeSplitStrategy SPLIT_STRATEGY_FIRST_PROPOSAL = SatParameters_SharedTreeSplitStrategy_SPLIT_STRATEGY_FIRST_PROPOSAL;
  static inline bool SharedTreeSplitStrategy_IsValid(int value) {
    return SatParameters_SharedTreeSplitStrategy_IsValid(value);
  }
  static constexpr SharedTreeSplitStrategy SharedTreeSplitStrategy_MIN = SatParameters_SharedTreeSplitStrategy_SharedTreeSplitStrategy_MIN;
  static constexpr SharedTreeSplitStrategy SharedTreeSplitStrategy_MAX = SatParameters_SharedTreeSplitStrategy_SharedTreeSplitStrategy_MAX;
  static constexpr int SharedTreeSplitStrategy_ARRAYSIZE = SatParameters_SharedTreeSplitStrategy_SharedTreeSplitStrategy_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SharedTreeSplitStrategy_descriptor() {
    return SatParameters_SharedTreeSplitStrategy_descriptor();
  }
  template <typename T>
  static inline const ::std::string& SharedTreeSplitStrategy_Name(T value) {
    return SatParameters_SharedTreeSplitStrategy_Name(value);
  }
  static inline bool SharedTreeSplitStrategy_Parse(
      ::absl::string_view name, SharedTreeSplitStrategy* PROTOBUF_NONNULL value) {
    return SatParameters_SharedTreeSplitStrategy_Parse(name, value);
  }
  using FPRoundingMethod = SatParameters_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 ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL FPRoundingMethod_descriptor() {
    return SatParameters_FPRoundingMethod_descriptor();
  }
  template <typename T>
  static inline const ::std::string& FPRoundingMethod_Name(T value) {
    return SatParameters_FPRoundingMethod_Name(value);
  }
  static inline bool FPRoundingMethod_Parse(
      ::absl::string_view name, FPRoundingMethod* PROTOBUF_NONNULL value) {
    return SatParameters_FPRoundingMethod_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
  enum : int {
    kPreferredVariableOrderFieldNumber = 1,
    kClauseCleanupTargetFieldNumber = 13,
    kRandomPolarityRatioFieldNumber = 45,
    kLogSearchProgressFieldNumber = 41,
    kUsePbResolutionFieldNumber = 43,
    kUseOptimizationHintsFieldNumber = 35,
    kUsePhaseSavingFieldNumber = 44,
    kUsePrecedencesInDisjunctiveConstraintFieldNumber = 74,
    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,
    kRestartAlgorithmsFieldNumber = 61,
    kSubsolversFieldNumber = 207,
    kIgnoreSubsolversFieldNumber = 209,
    kSubsolverParamsFieldNumber = 210,
    kExtraSubsolversFieldNumber = 219,
    kFilterSubsolversFieldNumber = 293,
    kDefaultRestartAlgorithmsFieldNumber = 70,
    kNameFieldNumber = 171,
    kLogPrefixFieldNumber = 185,
    kRandomBranchesRatioFieldNumber = 32,
    kMaxSatAssumptionOrderFieldNumber = 51,
    kMinimizeReductionDuringPbResolutionFieldNumber = 48,
    kMaxSatReverseAssumptionOrderFieldNumber = 52,
    kUseBlockingRestartFieldNumber = 64,
    kUseErwaHeuristicFieldNumber = 75,
    kClauseCleanupOrderingFieldNumber = 60,
    kNumConflictsBeforeStrategyChangesFieldNumber = 68,
    kStrategyChangeIncreaseRatioFieldNumber = 69,
    kInitialVariablesActivityFieldNumber = 76,
    kAlsoBumpVariablesInConflictReasonsFieldNumber = 77,
    kUseOverloadCheckerInCumulativeFieldNumber = 78,
    kUseTimetableEdgeFindingInCumulativeFieldNumber = 79,
    kOptimizeWithCoreFieldNumber = 83,
    kSearchBranchingFieldNumber = 82,
    kOptimizeWithMaxHsFieldNumber = 85,
    kEnumerateAllSolutionsFieldNumber = 87,
    kOnlyAddCutsAtLevelZeroFieldNumber = 92,
    kStopAfterFirstSolutionFieldNumber = 98,
    kNumSearchWorkersFieldNumber = 100,
    kSearchRandomVariablePoolSizeFieldNumber = 104,
    kUseLnsOnlyFieldNumber = 101,
    kRandomizeSearchFieldNumber = 103,
    kUseOptionalVariablesFieldNumber = 108,
    kExploitBestSolutionFieldNumber = 130,
    kInterleaveBatchSizeFieldNumber = 134,
    kFillTightenedDomainsInResponseFieldNumber = 132,
    kUseCombinedNoOverlapFieldNumber = 133,
    kInterleaveSearchFieldNumber = 136,
    kDiversifyLnsParamsFieldNumber = 137,
    kDebugMaxNumPresolveOperationsFieldNumber = 151,
    kRelativeGapLimitFieldNumber = 160,
    kStopAfterPresolveFieldNumber = 149,
    kExploitRelaxationSolutionFieldNumber = 161,
    kDebugPostsolveWithFullSolverFieldNumber = 162,
    kRepairHintFieldNumber = 167,
    kExpandAlldiffConstraintsFieldNumber = 170,
    kKeepAllFeasibleSolutionsInPresolveFieldNumber = 173,
    kPresolveExtractIntegerEnforcementFieldNumber = 174,
    kPolishLpSolutionFieldNumber = 175,
    kUseProbingSearchFieldNumber = 176,
    kPermuteVariableRandomlyFieldNumber = 178,
    kPermutePresolveConstraintOrderFieldNumber = 179,
    kUseAbslRandomFieldNumber = 180,
    kDisableConstraintExpansionFieldNumber = 181,
    kLogToResponseFieldNumber = 187,
    kOptimizeWithLbTreeSearchFieldNumber = 188,
    kLogSubsolverStatisticsFieldNumber = 189,
    kFixVariablesToTheirHintedValueFieldNumber = 192,
    kFillAdditionalSolutionsInResponseFieldNumber = 194,
    kDebugCrashOnBadHintFieldNumber = 195,
    kAddObjectiveCutFieldNumber = 197,
    kNumWorkersFieldNumber = 206,
    kUseTimetablingInNoOverlap2DFieldNumber = 200,
    kUseEnergeticReasoningInNoOverlap2DFieldNumber = 213,
    kUseHardPrecedencesInCumulativeFieldNumber = 215,
    kDetectTableWithCostFieldNumber = 216,
    kExploitAllPrecedencesFieldNumber = 220,
    kOnlySolveIpFieldNumber = 222,
    kEncodeComplexLinearConstraintWithIntegerFieldNumber = 223,
    kMipScaleLargeDomainFieldNumber = 225,
    kUseObjectiveLbSearchFieldNumber = 228,
    kUseStrongPropagationInDisjunctiveFieldNumber = 230,
    kUseSharedTreeSearchFieldNumber = 236,
    kUseLsOnlyFieldNumber = 240,
    kSharedTreeSplitStrategyFieldNumber = 239,
    kNumViolationLsFieldNumber = 244,
    kStopAfterRootPropagationFieldNumber = 252,
    kUseObjectiveShavingSearchFieldNumber = 253,
    kPushAllTasksTowardStartFieldNumber = 262,
    kUseDynamicPrecedenceInDisjunctiveFieldNumber = 263,
    kUseDynamicPrecedenceInCumulativeFieldNumber = 268,
    kUseAreaEnergeticReasoningInNoOverlap2DFieldNumber = 271,
    kDetectLinearizedProductFieldNumber = 277,
    kMipTreatHighMagnitudeBoundsAsInfinityFieldNumber = 278,
    kMaxLinMaxSizeForExpansionFieldNumber = 280,
    kSaveLpBasisInLbTreeSearchFieldNumber = 284,
    kUseConservativeScaleOverloadCheckerFieldNumber = 286,
    kEncodeCumulativeAsReservoirFieldNumber = 287,
    kExpandReservoirUsingCircuitFieldNumber = 288,
    kMaxNumDeterministicBatchesFieldNumber = 291,
    kNumFullSubsolversFieldNumber = 294,
    kInprocessingMinimizationUseAllOrderingsFieldNumber = 298,
    kUseTryEdgeReasoningInNoOverlap2DFieldNumber = 299,
    kUseSymmetryInLpFieldNumber = 301,
    kKeepSymmetryInPresolveFieldNumber = 303,
    kRoutingCutSubsetSizeForBinaryRelationBoundFieldNumber = 312,
    kDebugCrashIfPresolveBreaksHintFieldNumber = 306,
    kPolarityExploitLsHintsFieldNumber = 309,
    kUseAllDifferentForCircuitFieldNumber = 311,
    kFilterSatPostsolveClausesFieldNumber = 324,
    kRoutingCutSubsetSizeForTightBinaryRelationBoundFieldNumber = 313,
    kMaximumRegionsToSplitInDisconnectedNoOverlap2DFieldNumber = 315,
    kShareLinear2BoundsFieldNumber = 326,
    kUseChronologicalBacktrackingFieldNumber = 330,
    kLoadAtMostOnesInSatPresolveFieldNumber = 335,
    kUseNewIntegerConflictResolutionFieldNumber = 336,
    kClauseCleanupPeriodIncrementFieldNumber = 337,
    kDebugCrashIfLratCheckFailsFieldNumber = 339,
    kCheckLratProofFieldNumber = 344,
    kOutputLratProofFieldNumber = 345,
    kCheckDratProofFieldNumber = 346,
    kClauseCleanupLbdTier1FieldNumber = 349,
    kClauseCleanupLbdTier2FieldNumber = 350,
    kOutputDratProofFieldNumber = 347,
    kCheckMergedLratProofFieldNumber = 352,
    kInprocessingUseSatSweepingFieldNumber = 354,
    kMaxMemoryInMbFieldNumber = 40,
    kBinaryMinimizationAlgorithmFieldNumber = 34,
    kPbCleanupIncrementFieldNumber = 46,
    kPbCleanupRatioFieldNumber = 47,
    kCoreMinimizationLevelFieldNumber = 50,
    kMaxSatStratificationFieldNumber = 53,
    kPresolveBveThresholdFieldNumber = 54,
    kPresolveBveClauseWeightFieldNumber = 55,
    kPresolveProbingDeterministicTimeLimitFieldNumber = 57,
    kClauseCleanupLbdBoundFieldNumber = 59,
    kRestartRunningWindowSizeFieldNumber = 62,
    kRestartDlAverageRatioFieldNumber = 63,
    kCountAssumptionLevelsInLbdFieldNumber = 49,
    kSubsumptionDuringConflictAnalysisFieldNumber = 56,
    kPresolveUseBvaFieldNumber = 72,
    kUseDisjunctiveConstraintInCumulativeFieldNumber = 80,
    kBlockingRestartWindowSizeFieldNumber = 65,
    kBlockingRestartMultiplierFieldNumber = 66,
    kMaxDeterministicTimeFieldNumber = 67,
    kRestartLbdAverageRatioFieldNumber = 71,
    kPresolveBvaThresholdFieldNumber = 73,
    kFindMultipleCoresFieldNumber = 84,
    kCpModelPresolveFieldNumber = 86,
    kPresolveBlockedClauseFieldNumber = 88,
    kCoverOptimizationFieldNumber = 89,
    kLinearizationLevelFieldNumber = 90,
    kMaxNumCutsFieldNumber = 91,
    kCpModelUseSatPresolveFieldNumber = 93,
    kExploitIntegerLpSolutionFieldNumber = 94,
    kAutoDetectGreaterThanAtLeastOneOfFieldNumber = 95,
    kInstantiateAllVariablesFieldNumber = 106,
    kBinarySearchNumConflictsFieldNumber = 99,
    kBooleanEncodingLevelFieldNumber = 107,
    kCpModelProbingLevelFieldNumber = 110,
    kUseExactLpReasonFieldNumber = 109,
    kAddLpConstraintsLazilyFieldNumber = 112,
    kShareObjectiveBoundsFieldNumber = 113,
    kShareLevelZeroBoundsFieldNumber = 114,
    kMaxIntegerRoundingScalingFieldNumber = 119,
    kMinOrthogonalityForLpConstraintsFieldNumber = 115,
    kExploitAllLpSolutionFieldNumber = 116,
    kAddCgCutsFieldNumber = 117,
    kAddMirCutsFieldNumber = 120,
    kUseRinsLnsFieldNumber = 129,
    kMaxConsecutiveInactiveCountFieldNumber = 121,
    kPseudoCostReliabilityThresholdFieldNumber = 123,
    kMipMaxBoundFieldNumber = 124,
    kNewConstraintsBatchSizeFieldNumber = 122,
    kMipMaxActivityExponentFieldNumber = 127,
    kMipVarScalingFieldNumber = 125,
    kMipWantedPrecisionFieldNumber = 126,
    kMipCheckPrecisionFieldNumber = 128,
    kMaxPresolveIterationsFieldNumber = 138,
    kExploitObjectiveFieldNumber = 131,
    kCatchSigintSignalFieldNumber = 135,
    kUseImpliedBoundsFieldNumber = 144,
    kAddLinMaxCutsFieldNumber = 152,
    kMergeNoOverlapWorkLimitFieldNumber = 145,
    kMergeAtMostOneWorkLimitFieldNumber = 146,
    kPresolveSubstitutionLevelFieldNumber = 147,
    kMaxAllDiffCutSizeFieldNumber = 148,
    kHintConflictLimitFieldNumber = 153,
    kMaxCutRoundsAtLevelZeroFieldNumber = 154,
    kCutMaxActiveCountValueFieldNumber = 155,
    kCutActiveCountDecayFieldNumber = 156,
    kAbsoluteGapLimitFieldNumber = 159,
    kCutCleanupTargetFieldNumber = 157,
    kFpRoundingFieldNumber = 165,
    kUseSatInprocessingFieldNumber = 163,
    kUseFeasibilityPumpFieldNumber = 164,
    kMipAutomaticallyScaleVariablesFieldNumber = 166,
    kAddZeroHalfCutsFieldNumber = 169,
    kPolarityRephaseIncrementFieldNumber = 168,
    kAddCliqueCutsFieldNumber = 172,
    kConvertIntervalsFieldNumber = 177,
    kExpandReservoirConstraintsFieldNumber = 182,
    kLogToStdoutFieldNumber = 186,
    kSymmetryLevelFieldNumber = 183,
    kClauseCleanupRatioFieldNumber = 190,
    kMaxDomainSizeWhenEncodingEqNeqConstraintsFieldNumber = 191,
    kSolutionPoolSizeFieldNumber = 193,
    kMipMaxValidMagnitudeFieldNumber = 199,
    kPresolveInclusionWorkLimitFieldNumber = 201,
    kCutLevelFieldNumber = 196,
    kMipComputeTrueObjectiveBoundFieldNumber = 198,
    kIgnoreNamesFieldNumber = 202,
    kShareBinaryClausesFieldNumber = 203,
    kUseDualSchedulingHeuristicsFieldNumber = 214,
    kShavingDeterministicTimeInProbingSearchFieldNumber = 204,
    kShavingSearchDeterministicTimeFieldNumber = 205,
    kPropagationLoopDetectionFactorFieldNumber = 221,
    kTableCompressionLevelFieldNumber = 217,
    kRootLpIterationsFieldNumber = 227,
    kProbingDeterministicTimeLimitFieldNumber = 226,
    kMipDropToleranceFieldNumber = 232,
    kMaxSizeToCreatePrecedenceLiteralsInDisjunctiveFieldNumber = 229,
    kSharedTreeNumWorkersFieldNumber = 235,
    kNewLinearPropagationFieldNumber = 224,
    kInferAllDiffsFieldNumber = 233,
    kFindBigLinearOverlapFieldNumber = 234,
    kFeasibilityJumpEnableRestartsFieldNumber = 250,
    kSharedTreeMaxNodesPerWorkerFieldNumber = 238,
    kFeasibilityJumpDecayFieldNumber = 242,
    kFeasibilityJumpVarRandomizationProbabilityFieldNumber = 247,
    kFeasibilityJumpVarPerburbationRangeRatioFieldNumber = 248,
    kViolationLsPerturbationPeriodFieldNumber = 249,
    kLinearSplitSizeFieldNumber = 256,
    kFeasibilityJumpLinearizationLevelFieldNumber = 257,
    kFeasibilityJumpRestartFactorFieldNumber = 258,
    kViolationLsCompoundMoveProbabilityFieldNumber = 259,
    kMaxNumIntervalsForTimetableEdgeFindingFieldNumber = 260,
    kMipPresolveLevelFieldNumber = 261,
    kLpPrimalToleranceFieldNumber = 266,
    kFeasibilityJumpMaxExpandedConstraintSizeFieldNumber = 264,
    kUseLbRelaxLnsFieldNumber = 255,
    kUseFeasibilityJumpFieldNumber = 265,
    kUseExtendedProbingFieldNumber = 269,
    kAddRltCutsFieldNumber = 279,
    kLpDualToleranceFieldNumber = 267,
    kAtMostOneMaxExpansionSizeFieldNumber = 270,
    kProbingNumCombinationsLimitFieldNumber = 272,
    kInprocessingDtimeRatioFieldNumber = 273,
    kInprocessingProbingDtimeFieldNumber = 274,
    kInprocessingMinimizationDtimeFieldNumber = 275,
    kMaxPairsPairwiseReasoningInNoOverlap2DFieldNumber = 276,
    kSharedTreeWorkerMinRestartsPerSubtreeFieldNumber = 282,
    kSharedTreeOpenLeavesPerWorkerFieldNumber = 281,
    kVariablesShavingLevelFieldNumber = 289,
    kUseLnsFieldNumber = 283,
    kShareGlueClausesFieldNumber = 285,
    kSharedTreeWorkerEnableTrailSharingFieldNumber = 295,
    kInprocessingMinimizationUseConflictAnalysisFieldNumber = 297,
    kShavingSearchThresholdFieldNumber = 290,
    kFeasibilityJumpBatchDtimeFieldNumber = 292,
    kLbRelaxNumWorkersThresholdFieldNumber = 296,
    kSharedTreeBalanceToleranceFieldNumber = 305,
    kSymmetryDetectionDeterministicTimeLimitFieldNumber = 302,
    kLnsInitialDifficultyFieldNumber = 307,
    kLnsInitialDeterministicLimitFieldNumber = 308,
    kMinimizeSharedClausesFieldNumber = 300,
    kSharedTreeWorkerEnablePhaseSharingFieldNumber = 304,
    kRemoveFixedVariablesEarlyFieldNumber = 310,
    kUseLinear3ForNoOverlap2DPrecedencesFieldNumber = 323,
    kRoutingCutSubsetSizeForExactBinaryRelationBoundFieldNumber = 316,
    kRoutingCutDpEffortFieldNumber = 314,
    kRoutingCutMaxInfeasiblePathLengthFieldNumber = 317,
    kRoutingCutSubsetSizeForShortestPathsBoundFieldNumber = 318,
    kMaxAlldiffDomainSizeFieldNumber = 320,
    kNoOverlap2DBooleanRelationsLimitFieldNumber = 321,
    kShareGlueClausesDtimeFieldNumber = 322,
    kAlternativePoolSizeFieldNumber = 325,
    kTransitivePrecedencesWorkLimitFieldNumber = 327,
    kSharedTreeSplitMinDtimeFieldNumber = 328,
    kSolutionPoolDiversityLimitFieldNumber = 329,
    kMaxBackjumpLevelsFieldNumber = 331,
    kChronologicalBacktrackMinConflictsFieldNumber = 332,
    kMaxDomainSizeForLinear2ExpansionFieldNumber = 340,
    kFindClausesThatAreExactlyOneFieldNumber = 333,
    kCreate1UipBooleanDuringIcrFieldNumber = 341,
    kInprocessingUseCongruenceClosureFieldNumber = 342,
    kExtraSubsumptionDuringConflictAnalysisFieldNumber = 351,
    kEagerlySubsumeLastNConflictsFieldNumber = 343,
    kMaxDratTimeInSecondsFieldNumber = 348,
    kDecisionSubsumptionDuringConflictAnalysisFieldNumber = 353,
    kSubsumeDuringVivificationFieldNumber = 355,
  };
  // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  bool has_preferred_variable_order() const;
  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;
  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_polarity_ratio = 45 [default = 0];
  bool has_random_polarity_ratio() const;
  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 bool log_search_progress = 41 [default = false];
  bool has_log_search_progress() const;
  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 use_pb_resolution = 43 [default = false];
  bool has_use_pb_resolution() const;
  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 use_optimization_hints = 35 [default = true];
  bool has_use_optimization_hints() const;
  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 use_phase_saving = 44 [default = true];
  bool has_use_phase_saving() const;
  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 use_precedences_in_disjunctive_constraint = 74 [default = true];
  bool has_use_precedences_in_disjunctive_constraint() const;
  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 .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  bool has_initial_polarity() const;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  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:
  // 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() ;
  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 ::google::protobuf::RepeatedField<int>& restart_algorithms() const;
  ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL mutable_restart_algorithms();
 
  private:
  const ::google::protobuf::RepeatedField<int>& _internal_restart_algorithms() const;
  ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL _internal_mutable_restart_algorithms();
 
  public:
  // repeated string subsolvers = 207;
  int subsolvers_size() const;
  private:
  int _internal_subsolvers_size() const;
 
  public:
  void clear_subsolvers() ;
  const ::std::string& subsolvers(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_subsolvers(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_subsolvers(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_subsolvers();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_subsolvers(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<::std::string>& subsolvers() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_subsolvers();
 
  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_subsolvers() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_subsolvers();
 
  public:
  // repeated string ignore_subsolvers = 209;
  int ignore_subsolvers_size() const;
  private:
  int _internal_ignore_subsolvers_size() const;
 
  public:
  void clear_ignore_subsolvers() ;
  const ::std::string& ignore_subsolvers(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_ignore_subsolvers(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_ignore_subsolvers(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_ignore_subsolvers();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_ignore_subsolvers(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<::std::string>& ignore_subsolvers() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_ignore_subsolvers();
 
  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_ignore_subsolvers() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_ignore_subsolvers();
 
  public:
  // repeated .operations_research.sat.SatParameters subsolver_params = 210;
  int subsolver_params_size() const;
  private:
  int _internal_subsolver_params_size() const;
 
  public:
  void clear_subsolver_params() ;
  ::operations_research::sat::SatParameters* PROTOBUF_NONNULL mutable_subsolver_params(int index);
  ::google::protobuf::RepeatedPtrField<::operations_research::sat::SatParameters>* PROTOBUF_NONNULL mutable_subsolver_params();
 
  private:
  const ::google::protobuf::RepeatedPtrField<::operations_research::sat::SatParameters>& _internal_subsolver_params() const;
  ::google::protobuf::RepeatedPtrField<::operations_research::sat::SatParameters>* PROTOBUF_NONNULL _internal_mutable_subsolver_params();
  public:
  const ::operations_research::sat::SatParameters& subsolver_params(int index) const;
  ::operations_research::sat::SatParameters* PROTOBUF_NONNULL add_subsolver_params();
  const ::google::protobuf::RepeatedPtrField<::operations_research::sat::SatParameters>& subsolver_params() const;
  // repeated string extra_subsolvers = 219;
  int extra_subsolvers_size() const;
  private:
  int _internal_extra_subsolvers_size() const;
 
  public:
  void clear_extra_subsolvers() ;
  const ::std::string& extra_subsolvers(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_extra_subsolvers(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_extra_subsolvers(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_extra_subsolvers();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_extra_subsolvers(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<::std::string>& extra_subsolvers() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_extra_subsolvers();
 
  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_extra_subsolvers() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_extra_subsolvers();
 
  public:
  // repeated string filter_subsolvers = 293;
  int filter_subsolvers_size() const;
  private:
  int _internal_filter_subsolvers_size() const;
 
  public:
  void clear_filter_subsolvers() ;
  const ::std::string& filter_subsolvers(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_filter_subsolvers(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_filter_subsolvers(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_filter_subsolvers();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_filter_subsolvers(Arg_&& value, Args_... args);
  const ::google::protobuf::RepeatedPtrField<::std::string>& filter_subsolvers() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_filter_subsolvers();
 
  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_filter_subsolvers() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_filter_subsolvers();
 
  public:
  // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  bool has_default_restart_algorithms() const;
  void clear_default_restart_algorithms() ;
  const ::std::string& default_restart_algorithms() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_default_restart_algorithms(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_default_restart_algorithms();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_default_restart_algorithms();
  void set_allocated_default_restart_algorithms(::std::string* PROTOBUF_NULLABLE value);
 
  private:
  const ::std::string& _internal_default_restart_algorithms() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_default_restart_algorithms(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_default_restart_algorithms();
 
  public:
  // optional string name = 171 [default = ""];
  bool has_name() const;
  void clear_name() ;
  const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);
 
  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();
 
  public:
  // optional string log_prefix = 185 [default = ""];
  bool has_log_prefix() const;
  void clear_log_prefix() ;
  const ::std::string& log_prefix() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_log_prefix(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_log_prefix();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_log_prefix();
  void set_allocated_log_prefix(::std::string* PROTOBUF_NULLABLE value);
 
  private:
  const ::std::string& _internal_log_prefix() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_log_prefix(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_log_prefix();
 
  public:
  // optional double random_branches_ratio = 32 [default = 0];
  bool has_random_branches_ratio() const;
  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 .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  bool has_max_sat_assumption_order() const;
  void clear_max_sat_assumption_order() ;
  ::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 bool minimize_reduction_during_pb_resolution = 48 [default = false];
  bool has_minimize_reduction_during_pb_resolution() const;
  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 max_sat_reverse_assumption_order = 52 [default = false];
  bool has_max_sat_reverse_assumption_order() const;
  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_blocking_restart = 64 [default = false];
  bool has_use_blocking_restart() const;
  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 use_erwa_heuristic = 75 [default = false];
  bool has_use_erwa_heuristic() const;
  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 .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  bool has_clause_cleanup_ordering() const;
  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;
  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;
  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;
  void clear_initial_variables_activity() ;
  double initial_variables_activity() const;
  void set_initial_variables_activity(double value);
 
  private:
  double _internal_initial_variables_activity() const;
  void _internal_set_initial_variables_activity(double value);
 
  public:
  // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  bool has_also_bump_variables_in_conflict_reasons() const;
  void clear_also_bump_variables_in_conflict_reasons() ;
  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_overload_checker_in_cumulative = 78 [default = false];
  bool has_use_overload_checker_in_cumulative() const;
  void clear_use_overload_checker_in_cumulative() ;
  bool use_overload_checker_in_cumulative() const;
  void set_use_overload_checker_in_cumulative(bool value);
 
  private:
  bool _internal_use_overload_checker_in_cumulative() const;
  void _internal_set_use_overload_checker_in_cumulative(bool value);
 
  public:
  // optional bool use_timetable_edge_finding_in_cumulative = 79 [default = false];
  bool has_use_timetable_edge_finding_in_cumulative() const;
  void clear_use_timetable_edge_finding_in_cumulative() ;
  bool use_timetable_edge_finding_in_cumulative() const;
  void set_use_timetable_edge_finding_in_cumulative(bool value);
 
  private:
  bool _internal_use_timetable_edge_finding_in_cumulative() const;
  void _internal_set_use_timetable_edge_finding_in_cumulative(bool value);
 
  public:
  // optional bool optimize_with_core = 83 [default = false];
  bool has_optimize_with_core() const;
  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 .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  bool has_search_branching() const;
  void clear_search_branching() ;
  ::operations_research::sat::SatParameters_SearchBranching search_branching() const;
  void set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);
 
  private:
  ::operations_research::sat::SatParameters_SearchBranching _internal_search_branching() const;
  void _internal_set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);
 
  public:
  // optional bool optimize_with_max_hs = 85 [default = false];
  bool has_optimize_with_max_hs() const;
  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;
  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 only_add_cuts_at_level_zero = 92 [default = false];
  bool has_only_add_cuts_at_level_zero() const;
  void clear_only_add_cuts_at_level_zero() ;
  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 stop_after_first_solution = 98 [default = false];
  bool has_stop_after_first_solution() const;
  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 int32 num_search_workers = 100 [default = 0];
  bool has_num_search_workers() const;
  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 int64 search_random_variable_pool_size = 104 [default = 0];
  bool has_search_random_variable_pool_size() const;
  void clear_search_random_variable_pool_size() ;
  ::int64_t search_random_variable_pool_size() const;
  void set_search_random_variable_pool_size(::int64_t value);
 
  private:
  ::int64_t _internal_search_random_variable_pool_size() const;
  void _internal_set_search_random_variable_pool_size(::int64_t value);
 
  public:
  // optional bool use_lns_only = 101 [default = false];
  bool has_use_lns_only() const;
  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 randomize_search = 103 [default = false];
  bool has_randomize_search() const;
  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_optional_variables = 108 [default = false];
  bool has_use_optional_variables() const;
  void clear_use_optional_variables() ;
  bool use_optional_variables() const;
  void set_use_optional_variables(bool value);
 
  private:
  bool _internal_use_optional_variables() const;
  void _internal_set_use_optional_variables(bool value);
 
  public:
  // optional bool exploit_best_solution = 130 [default = false];
  bool has_exploit_best_solution() const;
  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 int32 interleave_batch_size = 134 [default = 0];
  bool has_interleave_batch_size() const;
  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 bool fill_tightened_domains_in_response = 132 [default = false];
  bool has_fill_tightened_domains_in_response() const;
  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 use_combined_no_overlap = 133 [default = false];
  bool has_use_combined_no_overlap() const;
  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;
  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 diversify_lns_params = 137 [default = false];
  bool has_diversify_lns_params() const;
  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 int32 debug_max_num_presolve_operations = 151 [default = 0];
  bool has_debug_max_num_presolve_operations() const;
  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;
  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 stop_after_presolve = 149 [default = false];
  bool has_stop_after_presolve() const;
  void clear_stop_after_presolve() ;
  bool stop_after_presolve() const;
  void set_stop_after_presolve(bool value);
 
  private:
  bool _internal_stop_after_presolve() const;
  void _internal_set_stop_after_presolve(bool value);
 
  public:
  // optional bool exploit_relaxation_solution = 161 [default = false];
  bool has_exploit_relaxation_solution() const;
  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 debug_postsolve_with_full_solver = 162 [default = false];
  bool has_debug_postsolve_with_full_solver() const;
  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 repair_hint = 167 [default = false];
  bool has_repair_hint() const;
  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 expand_alldiff_constraints = 170 [default = false];
  bool has_expand_alldiff_constraints() const;
  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 keep_all_feasible_solutions_in_presolve = 173 [default = false];
  bool has_keep_all_feasible_solutions_in_presolve() const;
  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 presolve_extract_integer_enforcement = 174 [default = false];
  bool has_presolve_extract_integer_enforcement() const;
  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 polish_lp_solution = 175 [default = false];
  bool has_polish_lp_solution() const;
  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 use_probing_search = 176 [default = false];
  bool has_use_probing_search() const;
  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 permute_variable_randomly = 178 [default = false];
  bool has_permute_variable_randomly() const;
  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 bool permute_presolve_constraint_order = 179 [default = false];
  bool has_permute_presolve_constraint_order() const;
  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;
  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 disable_constraint_expansion = 181 [default = false];
  bool has_disable_constraint_expansion() const;
  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 log_to_response = 187 [default = false];
  bool has_log_to_response() const;
  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 bool optimize_with_lb_tree_search = 188 [default = false];
  bool has_optimize_with_lb_tree_search() const;
  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 log_subsolver_statistics = 189 [default = false];
  bool has_log_subsolver_statistics() const;
  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 fix_variables_to_their_hinted_value = 192 [default = false];
  bool has_fix_variables_to_their_hinted_value() const;
  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 fill_additional_solutions_in_response = 194 [default = false];
  bool has_fill_additional_solutions_in_response() const;
  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 debug_crash_on_bad_hint = 195 [default = false];
  bool has_debug_crash_on_bad_hint() const;
  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 bool add_objective_cut = 197 [default = false];
  bool has_add_objective_cut() const;
  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 int32 num_workers = 206 [default = 0];
  bool has_num_workers() const;
  void clear_num_workers() ;
  ::int32_t num_workers() const;
  void set_num_workers(::int32_t value);
 
  private:
  ::int32_t _internal_num_workers() const;
  void _internal_set_num_workers(::int32_t value);
 
  public:
  // optional bool use_timetabling_in_no_overlap_2d = 200 [default = false];
  bool has_use_timetabling_in_no_overlap_2d() const;
  void clear_use_timetabling_in_no_overlap_2d() ;
  bool use_timetabling_in_no_overlap_2d() const;
  void set_use_timetabling_in_no_overlap_2d(bool value);
 
  private:
  bool _internal_use_timetabling_in_no_overlap_2d() const;
  void _internal_set_use_timetabling_in_no_overlap_2d(bool value);
 
  public:
  // optional bool use_energetic_reasoning_in_no_overlap_2d = 213 [default = false];
  bool has_use_energetic_reasoning_in_no_overlap_2d() const;
  void clear_use_energetic_reasoning_in_no_overlap_2d() ;
  bool use_energetic_reasoning_in_no_overlap_2d() const;
  void set_use_energetic_reasoning_in_no_overlap_2d(bool value);
 
  private:
  bool _internal_use_energetic_reasoning_in_no_overlap_2d() const;
  void _internal_set_use_energetic_reasoning_in_no_overlap_2d(bool value);
 
  public:
  // optional bool use_hard_precedences_in_cumulative = 215 [default = false];
  bool has_use_hard_precedences_in_cumulative() const;
  void clear_use_hard_precedences_in_cumulative() ;
  bool use_hard_precedences_in_cumulative() const;
  void set_use_hard_precedences_in_cumulative(bool value);
 
  private:
  bool _internal_use_hard_precedences_in_cumulative() const;
  void _internal_set_use_hard_precedences_in_cumulative(bool value);
 
  public:
  // optional bool detect_table_with_cost = 216 [default = false];
  bool has_detect_table_with_cost() const;
  void clear_detect_table_with_cost() ;
  bool detect_table_with_cost() const;
  void set_detect_table_with_cost(bool value);
 
  private:
  bool _internal_detect_table_with_cost() const;
  void _internal_set_detect_table_with_cost(bool value);
 
  public:
  // optional bool exploit_all_precedences = 220 [default = false];
  bool has_exploit_all_precedences() const;
  void clear_exploit_all_precedences() ;
  bool exploit_all_precedences() const;
  void set_exploit_all_precedences(bool value);
 
  private:
  bool _internal_exploit_all_precedences() const;
  void _internal_set_exploit_all_precedences(bool value);
 
  public:
  // optional bool only_solve_ip = 222 [default = false];
  bool has_only_solve_ip() const;
  void clear_only_solve_ip() ;
  bool only_solve_ip() const;
  void set_only_solve_ip(bool value);
 
  private:
  bool _internal_only_solve_ip() const;
  void _internal_set_only_solve_ip(bool value);
 
  public:
  // optional bool encode_complex_linear_constraint_with_integer = 223 [default = false];
  bool has_encode_complex_linear_constraint_with_integer() const;
  void clear_encode_complex_linear_constraint_with_integer() ;
  bool encode_complex_linear_constraint_with_integer() const;
  void set_encode_complex_linear_constraint_with_integer(bool value);
 
  private:
  bool _internal_encode_complex_linear_constraint_with_integer() const;
  void _internal_set_encode_complex_linear_constraint_with_integer(bool value);
 
  public:
  // optional bool mip_scale_large_domain = 225 [default = false];
  bool has_mip_scale_large_domain() const;
  void clear_mip_scale_large_domain() ;
  bool mip_scale_large_domain() const;
  void set_mip_scale_large_domain(bool value);
 
  private:
  bool _internal_mip_scale_large_domain() const;
  void _internal_set_mip_scale_large_domain(bool value);
 
  public:
  // optional bool use_objective_lb_search = 228 [default = false];
  bool has_use_objective_lb_search() const;
  void clear_use_objective_lb_search() ;
  bool use_objective_lb_search() const;
  void set_use_objective_lb_search(bool value);
 
  private:
  bool _internal_use_objective_lb_search() const;
  void _internal_set_use_objective_lb_search(bool value);
 
  public:
  // optional bool use_strong_propagation_in_disjunctive = 230 [default = false];
  bool has_use_strong_propagation_in_disjunctive() const;
  void clear_use_strong_propagation_in_disjunctive() ;
  bool use_strong_propagation_in_disjunctive() const;
  void set_use_strong_propagation_in_disjunctive(bool value);
 
  private:
  bool _internal_use_strong_propagation_in_disjunctive() const;
  void _internal_set_use_strong_propagation_in_disjunctive(bool value);
 
  public:
  // optional bool use_shared_tree_search = 236 [default = false];
  bool has_use_shared_tree_search() const;
  void clear_use_shared_tree_search() ;
  bool use_shared_tree_search() const;
  void set_use_shared_tree_search(bool value);
 
  private:
  bool _internal_use_shared_tree_search() const;
  void _internal_set_use_shared_tree_search(bool value);
 
  public:
  // optional bool use_ls_only = 240 [default = false];
  bool has_use_ls_only() const;
  void clear_use_ls_only() ;
  bool use_ls_only() const;
  void set_use_ls_only(bool value);
 
  private:
  bool _internal_use_ls_only() const;
  void _internal_set_use_ls_only(bool value);
 
  public:
  // optional .operations_research.sat.SatParameters.SharedTreeSplitStrategy shared_tree_split_strategy = 239 [default = SPLIT_STRATEGY_AUTO];
  bool has_shared_tree_split_strategy() const;
  void clear_shared_tree_split_strategy() ;
  ::operations_research::sat::SatParameters_SharedTreeSplitStrategy shared_tree_split_strategy() const;
  void set_shared_tree_split_strategy(::operations_research::sat::SatParameters_SharedTreeSplitStrategy value);
 
  private:
  ::operations_research::sat::SatParameters_SharedTreeSplitStrategy _internal_shared_tree_split_strategy() const;
  void _internal_set_shared_tree_split_strategy(::operations_research::sat::SatParameters_SharedTreeSplitStrategy value);
 
  public:
  // optional int32 num_violation_ls = 244 [default = 0];
  bool has_num_violation_ls() const;
  void clear_num_violation_ls() ;
  ::int32_t num_violation_ls() const;
  void set_num_violation_ls(::int32_t value);
 
  private:
  ::int32_t _internal_num_violation_ls() const;
  void _internal_set_num_violation_ls(::int32_t value);
 
  public:
  // optional bool stop_after_root_propagation = 252 [default = false];
  bool has_stop_after_root_propagation() const;
  void clear_stop_after_root_propagation() ;
  bool stop_after_root_propagation() const;
  void set_stop_after_root_propagation(bool value);
 
  private:
  bool _internal_stop_after_root_propagation() const;
  void _internal_set_stop_after_root_propagation(bool value);
 
  public:
  // optional bool use_objective_shaving_search = 253 [default = false];
  bool has_use_objective_shaving_search() const;
  void clear_use_objective_shaving_search() ;
  bool use_objective_shaving_search() const;
  void set_use_objective_shaving_search(bool value);
 
  private:
  bool _internal_use_objective_shaving_search() const;
  void _internal_set_use_objective_shaving_search(bool value);
 
  public:
  // optional bool push_all_tasks_toward_start = 262 [default = false];
  bool has_push_all_tasks_toward_start() const;
  void clear_push_all_tasks_toward_start() ;
  bool push_all_tasks_toward_start() const;
  void set_push_all_tasks_toward_start(bool value);
 
  private:
  bool _internal_push_all_tasks_toward_start() const;
  void _internal_set_push_all_tasks_toward_start(bool value);
 
  public:
  // optional bool use_dynamic_precedence_in_disjunctive = 263 [default = false];
  bool has_use_dynamic_precedence_in_disjunctive() const;
  void clear_use_dynamic_precedence_in_disjunctive() ;
  bool use_dynamic_precedence_in_disjunctive() const;
  void set_use_dynamic_precedence_in_disjunctive(bool value);
 
  private:
  bool _internal_use_dynamic_precedence_in_disjunctive() const;
  void _internal_set_use_dynamic_precedence_in_disjunctive(bool value);
 
  public:
  // optional bool use_dynamic_precedence_in_cumulative = 268 [default = false];
  bool has_use_dynamic_precedence_in_cumulative() const;
  void clear_use_dynamic_precedence_in_cumulative() ;
  bool use_dynamic_precedence_in_cumulative() const;
  void set_use_dynamic_precedence_in_cumulative(bool value);
 
  private:
  bool _internal_use_dynamic_precedence_in_cumulative() const;
  void _internal_set_use_dynamic_precedence_in_cumulative(bool value);
 
  public:
  // optional bool use_area_energetic_reasoning_in_no_overlap_2d = 271 [default = false];
  bool has_use_area_energetic_reasoning_in_no_overlap_2d() const;
  void clear_use_area_energetic_reasoning_in_no_overlap_2d() ;
  bool use_area_energetic_reasoning_in_no_overlap_2d() const;
  void set_use_area_energetic_reasoning_in_no_overlap_2d(bool value);
 
  private:
  bool _internal_use_area_energetic_reasoning_in_no_overlap_2d() const;
  void _internal_set_use_area_energetic_reasoning_in_no_overlap_2d(bool value);
 
  public:
  // optional bool detect_linearized_product = 277 [default = false];
  bool has_detect_linearized_product() const;
  void clear_detect_linearized_product() ;
  bool detect_linearized_product() const;
  void set_detect_linearized_product(bool value);
 
  private:
  bool _internal_detect_linearized_product() const;
  void _internal_set_detect_linearized_product(bool value);
 
  public:
  // optional bool mip_treat_high_magnitude_bounds_as_infinity = 278 [default = false];
  bool has_mip_treat_high_magnitude_bounds_as_infinity() const;
  void clear_mip_treat_high_magnitude_bounds_as_infinity() ;
  bool mip_treat_high_magnitude_bounds_as_infinity() const;
  void set_mip_treat_high_magnitude_bounds_as_infinity(bool value);
 
  private:
  bool _internal_mip_treat_high_magnitude_bounds_as_infinity() const;
  void _internal_set_mip_treat_high_magnitude_bounds_as_infinity(bool value);
 
  public:
  // optional int32 max_lin_max_size_for_expansion = 280 [default = 0];
  bool has_max_lin_max_size_for_expansion() const;
  void clear_max_lin_max_size_for_expansion() ;
  ::int32_t max_lin_max_size_for_expansion() const;
  void set_max_lin_max_size_for_expansion(::int32_t value);
 
  private:
  ::int32_t _internal_max_lin_max_size_for_expansion() const;
  void _internal_set_max_lin_max_size_for_expansion(::int32_t value);
 
  public:
  // optional bool save_lp_basis_in_lb_tree_search = 284 [default = false];
  bool has_save_lp_basis_in_lb_tree_search() const;
  void clear_save_lp_basis_in_lb_tree_search() ;
  bool save_lp_basis_in_lb_tree_search() const;
  void set_save_lp_basis_in_lb_tree_search(bool value);
 
  private:
  bool _internal_save_lp_basis_in_lb_tree_search() const;
  void _internal_set_save_lp_basis_in_lb_tree_search(bool value);
 
  public:
  // optional bool use_conservative_scale_overload_checker = 286 [default = false];
  bool has_use_conservative_scale_overload_checker() const;
  void clear_use_conservative_scale_overload_checker() ;
  bool use_conservative_scale_overload_checker() const;
  void set_use_conservative_scale_overload_checker(bool value);
 
  private:
  bool _internal_use_conservative_scale_overload_checker() const;
  void _internal_set_use_conservative_scale_overload_checker(bool value);
 
  public:
  // optional bool encode_cumulative_as_reservoir = 287 [default = false];
  bool has_encode_cumulative_as_reservoir() const;
  void clear_encode_cumulative_as_reservoir() ;
  bool encode_cumulative_as_reservoir() const;
  void set_encode_cumulative_as_reservoir(bool value);
 
  private:
  bool _internal_encode_cumulative_as_reservoir() const;
  void _internal_set_encode_cumulative_as_reservoir(bool value);
 
  public:
  // optional bool expand_reservoir_using_circuit = 288 [default = false];
  bool has_expand_reservoir_using_circuit() const;
  void clear_expand_reservoir_using_circuit() ;
  bool expand_reservoir_using_circuit() const;
  void set_expand_reservoir_using_circuit(bool value);
 
  private:
  bool _internal_expand_reservoir_using_circuit() const;
  void _internal_set_expand_reservoir_using_circuit(bool value);
 
  public:
  // optional int32 max_num_deterministic_batches = 291 [default = 0];
  bool has_max_num_deterministic_batches() const;
  void clear_max_num_deterministic_batches() ;
  ::int32_t max_num_deterministic_batches() const;
  void set_max_num_deterministic_batches(::int32_t value);
 
  private:
  ::int32_t _internal_max_num_deterministic_batches() const;
  void _internal_set_max_num_deterministic_batches(::int32_t value);
 
  public:
  // optional int32 num_full_subsolvers = 294 [default = 0];
  bool has_num_full_subsolvers() const;
  void clear_num_full_subsolvers() ;
  ::int32_t num_full_subsolvers() const;
  void set_num_full_subsolvers(::int32_t value);
 
  private:
  ::int32_t _internal_num_full_subsolvers() const;
  void _internal_set_num_full_subsolvers(::int32_t value);
 
  public:
  // optional bool inprocessing_minimization_use_all_orderings = 298 [default = false];
  bool has_inprocessing_minimization_use_all_orderings() const;
  void clear_inprocessing_minimization_use_all_orderings() ;
  bool inprocessing_minimization_use_all_orderings() const;
  void set_inprocessing_minimization_use_all_orderings(bool value);
 
  private:
  bool _internal_inprocessing_minimization_use_all_orderings() const;
  void _internal_set_inprocessing_minimization_use_all_orderings(bool value);
 
  public:
  // optional bool use_try_edge_reasoning_in_no_overlap_2d = 299 [default = false];
  bool has_use_try_edge_reasoning_in_no_overlap_2d() const;
  void clear_use_try_edge_reasoning_in_no_overlap_2d() ;
  bool use_try_edge_reasoning_in_no_overlap_2d() const;
  void set_use_try_edge_reasoning_in_no_overlap_2d(bool value);
 
  private:
  bool _internal_use_try_edge_reasoning_in_no_overlap_2d() const;
  void _internal_set_use_try_edge_reasoning_in_no_overlap_2d(bool value);
 
  public:
  // optional bool use_symmetry_in_lp = 301 [default = false];
  bool has_use_symmetry_in_lp() const;
  void clear_use_symmetry_in_lp() ;
  bool use_symmetry_in_lp() const;
  void set_use_symmetry_in_lp(bool value);
 
  private:
  bool _internal_use_symmetry_in_lp() const;
  void _internal_set_use_symmetry_in_lp(bool value);
 
  public:
  // optional bool keep_symmetry_in_presolve = 303 [default = false];
  bool has_keep_symmetry_in_presolve() const;
  void clear_keep_symmetry_in_presolve() ;
  bool keep_symmetry_in_presolve() const;
  void set_keep_symmetry_in_presolve(bool value);
 
  private:
  bool _internal_keep_symmetry_in_presolve() const;
  void _internal_set_keep_symmetry_in_presolve(bool value);
 
  public:
  // optional int32 routing_cut_subset_size_for_binary_relation_bound = 312 [default = 0];
  bool has_routing_cut_subset_size_for_binary_relation_bound() const;
  void clear_routing_cut_subset_size_for_binary_relation_bound() ;
  ::int32_t routing_cut_subset_size_for_binary_relation_bound() const;
  void set_routing_cut_subset_size_for_binary_relation_bound(::int32_t value);
 
  private:
  ::int32_t _internal_routing_cut_subset_size_for_binary_relation_bound() const;
  void _internal_set_routing_cut_subset_size_for_binary_relation_bound(::int32_t value);
 
  public:
  // optional bool debug_crash_if_presolve_breaks_hint = 306 [default = false];
  bool has_debug_crash_if_presolve_breaks_hint() const;
  void clear_debug_crash_if_presolve_breaks_hint() ;
  bool debug_crash_if_presolve_breaks_hint() const;
  void set_debug_crash_if_presolve_breaks_hint(bool value);
 
  private:
  bool _internal_debug_crash_if_presolve_breaks_hint() const;
  void _internal_set_debug_crash_if_presolve_breaks_hint(bool value);
 
  public:
  // optional bool polarity_exploit_ls_hints = 309 [default = false];
  bool has_polarity_exploit_ls_hints() const;
  void clear_polarity_exploit_ls_hints() ;
  bool polarity_exploit_ls_hints() const;
  void set_polarity_exploit_ls_hints(bool value);
 
  private:
  bool _internal_polarity_exploit_ls_hints() const;
  void _internal_set_polarity_exploit_ls_hints(bool value);
 
  public:
  // optional bool use_all_different_for_circuit = 311 [default = false];
  bool has_use_all_different_for_circuit() const;
  void clear_use_all_different_for_circuit() ;
  bool use_all_different_for_circuit() const;
  void set_use_all_different_for_circuit(bool value);
 
  private:
  bool _internal_use_all_different_for_circuit() const;
  void _internal_set_use_all_different_for_circuit(bool value);
 
  public:
  // optional bool filter_sat_postsolve_clauses = 324 [default = false];
  bool has_filter_sat_postsolve_clauses() const;
  void clear_filter_sat_postsolve_clauses() ;
  bool filter_sat_postsolve_clauses() const;
  void set_filter_sat_postsolve_clauses(bool value);
 
  private:
  bool _internal_filter_sat_postsolve_clauses() const;
  void _internal_set_filter_sat_postsolve_clauses(bool value);
 
  public:
  // optional int32 routing_cut_subset_size_for_tight_binary_relation_bound = 313 [default = 0];
  bool has_routing_cut_subset_size_for_tight_binary_relation_bound() const;
  void clear_routing_cut_subset_size_for_tight_binary_relation_bound() ;
  ::int32_t routing_cut_subset_size_for_tight_binary_relation_bound() const;
  void set_routing_cut_subset_size_for_tight_binary_relation_bound(::int32_t value);
 
  private:
  ::int32_t _internal_routing_cut_subset_size_for_tight_binary_relation_bound() const;
  void _internal_set_routing_cut_subset_size_for_tight_binary_relation_bound(::int32_t value);
 
  public:
  // optional int32 maximum_regions_to_split_in_disconnected_no_overlap_2d = 315 [default = 0];
  bool has_maximum_regions_to_split_in_disconnected_no_overlap_2d() const;
  void clear_maximum_regions_to_split_in_disconnected_no_overlap_2d() ;
  ::int32_t maximum_regions_to_split_in_disconnected_no_overlap_2d() const;
  void set_maximum_regions_to_split_in_disconnected_no_overlap_2d(::int32_t value);
 
  private:
  ::int32_t _internal_maximum_regions_to_split_in_disconnected_no_overlap_2d() const;
  void _internal_set_maximum_regions_to_split_in_disconnected_no_overlap_2d(::int32_t value);
 
  public:
  // optional bool share_linear2_bounds = 326 [default = false];
  bool has_share_linear2_bounds() const;
  void clear_share_linear2_bounds() ;
  bool share_linear2_bounds() const;
  void set_share_linear2_bounds(bool value);
 
  private:
  bool _internal_share_linear2_bounds() const;
  void _internal_set_share_linear2_bounds(bool value);
 
  public:
  // optional bool use_chronological_backtracking = 330 [default = false];
  bool has_use_chronological_backtracking() const;
  void clear_use_chronological_backtracking() ;
  bool use_chronological_backtracking() const;
  void set_use_chronological_backtracking(bool value);
 
  private:
  bool _internal_use_chronological_backtracking() const;
  void _internal_set_use_chronological_backtracking(bool value);
 
  public:
  // optional bool load_at_most_ones_in_sat_presolve = 335 [default = false];
  bool has_load_at_most_ones_in_sat_presolve() const;
  void clear_load_at_most_ones_in_sat_presolve() ;
  bool load_at_most_ones_in_sat_presolve() const;
  void set_load_at_most_ones_in_sat_presolve(bool value);
 
  private:
  bool _internal_load_at_most_ones_in_sat_presolve() const;
  void _internal_set_load_at_most_ones_in_sat_presolve(bool value);
 
  public:
  // optional bool use_new_integer_conflict_resolution = 336 [default = false];
  bool has_use_new_integer_conflict_resolution() const;
  void clear_use_new_integer_conflict_resolution() ;
  bool use_new_integer_conflict_resolution() const;
  void set_use_new_integer_conflict_resolution(bool value);
 
  private:
  bool _internal_use_new_integer_conflict_resolution() const;
  void _internal_set_use_new_integer_conflict_resolution(bool value);
 
  public:
  // optional int32 clause_cleanup_period_increment = 337 [default = 0];
  bool has_clause_cleanup_period_increment() const;
  void clear_clause_cleanup_period_increment() ;
  ::int32_t clause_cleanup_period_increment() const;
  void set_clause_cleanup_period_increment(::int32_t value);
 
  private:
  ::int32_t _internal_clause_cleanup_period_increment() const;
  void _internal_set_clause_cleanup_period_increment(::int32_t value);
 
  public:
  // optional bool debug_crash_if_lrat_check_fails = 339 [default = false];
  bool has_debug_crash_if_lrat_check_fails() const;
  void clear_debug_crash_if_lrat_check_fails() ;
  bool debug_crash_if_lrat_check_fails() const;
  void set_debug_crash_if_lrat_check_fails(bool value);
 
  private:
  bool _internal_debug_crash_if_lrat_check_fails() const;
  void _internal_set_debug_crash_if_lrat_check_fails(bool value);
 
  public:
  // optional bool check_lrat_proof = 344 [default = false];
  bool has_check_lrat_proof() const;
  void clear_check_lrat_proof() ;
  bool check_lrat_proof() const;
  void set_check_lrat_proof(bool value);
 
  private:
  bool _internal_check_lrat_proof() const;
  void _internal_set_check_lrat_proof(bool value);
 
  public:
  // optional bool output_lrat_proof = 345 [default = false];
  bool has_output_lrat_proof() const;
  void clear_output_lrat_proof() ;
  bool output_lrat_proof() const;
  void set_output_lrat_proof(bool value);
 
  private:
  bool _internal_output_lrat_proof() const;
  void _internal_set_output_lrat_proof(bool value);
 
  public:
  // optional bool check_drat_proof = 346 [default = false];
  bool has_check_drat_proof() const;
  void clear_check_drat_proof() ;
  bool check_drat_proof() const;
  void set_check_drat_proof(bool value);
 
  private:
  bool _internal_check_drat_proof() const;
  void _internal_set_check_drat_proof(bool value);
 
  public:
  // optional int32 clause_cleanup_lbd_tier1 = 349 [default = 0];
  bool has_clause_cleanup_lbd_tier1() const;
  void clear_clause_cleanup_lbd_tier1() ;
  ::int32_t clause_cleanup_lbd_tier1() const;
  void set_clause_cleanup_lbd_tier1(::int32_t value);
 
  private:
  ::int32_t _internal_clause_cleanup_lbd_tier1() const;
  void _internal_set_clause_cleanup_lbd_tier1(::int32_t value);
 
  public:
  // optional int32 clause_cleanup_lbd_tier2 = 350 [default = 0];
  bool has_clause_cleanup_lbd_tier2() const;
  void clear_clause_cleanup_lbd_tier2() ;
  ::int32_t clause_cleanup_lbd_tier2() const;
  void set_clause_cleanup_lbd_tier2(::int32_t value);
 
  private:
  ::int32_t _internal_clause_cleanup_lbd_tier2() const;
  void _internal_set_clause_cleanup_lbd_tier2(::int32_t value);
 
  public:
  // optional bool output_drat_proof = 347 [default = false];
  bool has_output_drat_proof() const;
  void clear_output_drat_proof() ;
  bool output_drat_proof() const;
  void set_output_drat_proof(bool value);
 
  private:
  bool _internal_output_drat_proof() const;
  void _internal_set_output_drat_proof(bool value);
 
  public:
  // optional bool check_merged_lrat_proof = 352 [default = false];
  bool has_check_merged_lrat_proof() const;
  void clear_check_merged_lrat_proof() ;
  bool check_merged_lrat_proof() const;
  void set_check_merged_lrat_proof(bool value);
 
  private:
  bool _internal_check_merged_lrat_proof() const;
  void _internal_set_check_merged_lrat_proof(bool value);
 
  public:
  // optional bool inprocessing_use_sat_sweeping = 354 [default = false];
  bool has_inprocessing_use_sat_sweeping() const;
  void clear_inprocessing_use_sat_sweeping() ;
  bool inprocessing_use_sat_sweeping() const;
  void set_inprocessing_use_sat_sweeping(bool value);
 
  private:
  bool _internal_inprocessing_use_sat_sweeping() const;
  void _internal_set_inprocessing_use_sat_sweeping(bool value);
 
  public:
  // optional int64 max_memory_in_mb = 40 [default = 10000];
  bool has_max_memory_in_mb() const;
  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_FROM_UIP_AND_DECISIONS];
  bool has_binary_minimization_algorithm() const;
  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;
  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;
  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 int32 core_minimization_level = 50 [default = 2];
  bool has_core_minimization_level() const;
  void clear_core_minimization_level() ;
  ::int32_t core_minimization_level() const;
  void set_core_minimization_level(::int32_t value);
 
  private:
  ::int32_t _internal_core_minimization_level() const;
  void _internal_set_core_minimization_level(::int32_t value);
 
  public:
  // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  bool has_max_sat_stratification() const;
  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;
  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 int32 presolve_bve_clause_weight = 55 [default = 3];
  bool has_presolve_bve_clause_weight() const;
  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 double presolve_probing_deterministic_time_limit = 57 [default = 30];
  bool has_presolve_probing_deterministic_time_limit() const;
  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 clause_cleanup_lbd_bound = 59 [default = 5];
  bool has_clause_cleanup_lbd_bound() const;
  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 int32 restart_running_window_size = 62 [default = 50];
  bool has_restart_running_window_size() const;
  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 double restart_dl_average_ratio = 63 [default = 1];
  bool has_restart_dl_average_ratio() const;
  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 bool count_assumption_levels_in_lbd = 49 [default = true];
  bool has_count_assumption_levels_in_lbd() const;
  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 subsumption_during_conflict_analysis = 56 [default = true];
  bool has_subsumption_during_conflict_analysis() const;
  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 presolve_use_bva = 72 [default = true];
  bool has_presolve_use_bva() const;
  void clear_presolve_use_bva() ;
  bool presolve_use_bva() const;
  void set_presolve_use_bva(bool value);
 
  private:
  bool _internal_presolve_use_bva() const;
  void _internal_set_presolve_use_bva(bool value);
 
  public:
  // optional bool use_disjunctive_constraint_in_cumulative = 80 [default = true];
  bool has_use_disjunctive_constraint_in_cumulative() const;
  void clear_use_disjunctive_constraint_in_cumulative() ;
  bool use_disjunctive_constraint_in_cumulative() const;
  void set_use_disjunctive_constraint_in_cumulative(bool value);
 
  private:
  bool _internal_use_disjunctive_constraint_in_cumulative() const;
  void _internal_set_use_disjunctive_constraint_in_cumulative(bool value);
 
  public:
  // optional int32 blocking_restart_window_size = 65 [default = 5000];
  bool has_blocking_restart_window_size() const;
  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;
  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;
  void clear_max_deterministic_time() ;
  double max_deterministic_time() const;
  void set_max_deterministic_time(double value);
 
  private:
  double _internal_max_deterministic_time() const;
  void _internal_set_max_deterministic_time(double value);
 
  public:
  // optional double restart_lbd_average_ratio = 71 [default = 1];
  bool has_restart_lbd_average_ratio() const;
  void clear_restart_lbd_average_ratio() ;
  double restart_lbd_average_ratio() const;
  void set_restart_lbd_average_ratio(double value);
 
  private:
  double _internal_restart_lbd_average_ratio() const;
  void _internal_set_restart_lbd_average_ratio(double value);
 
  public:
  // optional int32 presolve_bva_threshold = 73 [default = 1];
  bool has_presolve_bva_threshold() const;
  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 bool find_multiple_cores = 84 [default = true];
  bool has_find_multiple_cores() const;
  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 cp_model_presolve = 86 [default = true];
  bool has_cp_model_presolve() const;
  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 presolve_blocked_clause = 88 [default = true];
  bool has_presolve_blocked_clause() const;
  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 cover_optimization = 89 [default = true];
  bool has_cover_optimization() const;
  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 int32 linearization_level = 90 [default = 1];
  bool has_linearization_level() const;
  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;
  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 bool cp_model_use_sat_presolve = 93 [default = true];
  bool has_cp_model_use_sat_presolve() const;
  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 exploit_integer_lp_solution = 94 [default = true];
  bool has_exploit_integer_lp_solution() const;
  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 auto_detect_greater_than_at_least_one_of = 95 [default = true];
  bool has_auto_detect_greater_than_at_least_one_of() const;
  void clear_auto_detect_greater_than_at_least_one_of() ;
  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 instantiate_all_variables = 106 [default = true];
  bool has_instantiate_all_variables() const;
  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 int32 binary_search_num_conflicts = 99 [default = -1];
  bool has_binary_search_num_conflicts() const;
  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;
  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;
  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 use_exact_lp_reason = 109 [default = true];
  bool has_use_exact_lp_reason() const;
  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 add_lp_constraints_lazily = 112 [default = true];
  bool has_add_lp_constraints_lazily() const;
  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 share_objective_bounds = 113 [default = true];
  bool has_share_objective_bounds() const;
  void clear_share_objective_bounds() ;
  bool share_objective_bounds() const;
  void set_share_objective_bounds(bool value);
 
  private:
  bool _internal_share_objective_bounds() const;
  void _internal_set_share_objective_bounds(bool value);
 
  public:
  // optional bool share_level_zero_bounds = 114 [default = true];
  bool has_share_level_zero_bounds() const;
  void clear_share_level_zero_bounds() ;
  bool share_level_zero_bounds() const;
  void set_share_level_zero_bounds(bool value);
 
  private:
  bool _internal_share_level_zero_bounds() const;
  void _internal_set_share_level_zero_bounds(bool value);
 
  public:
  // optional int32 max_integer_rounding_scaling = 119 [default = 600];
  bool has_max_integer_rounding_scaling() const;
  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 double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  bool has_min_orthogonality_for_lp_constraints() const;
  void clear_min_orthogonality_for_lp_constraints() ;
  double min_orthogonality_for_lp_constraints() const;
  void set_min_orthogonality_for_lp_constraints(double value);
 
  private:
  double _internal_min_orthogonality_for_lp_constraints() const;
  void _internal_set_min_orthogonality_for_lp_constraints(double value);
 
  public:
  // optional bool exploit_all_lp_solution = 116 [default = true];
  bool has_exploit_all_lp_solution() const;
  void clear_exploit_all_lp_solution() ;
  bool exploit_all_lp_solution() const;
  void set_exploit_all_lp_solution(bool value);
 
  private:
  bool _internal_exploit_all_lp_solution() const;
  void _internal_set_exploit_all_lp_solution(bool value);
 
  public:
  // optional bool add_cg_cuts = 117 [default = true];
  bool has_add_cg_cuts() const;
  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;
  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 use_rins_lns = 129 [default = true];
  bool has_use_rins_lns() const;
  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 int32 max_consecutive_inactive_count = 121 [default = 100];
  bool has_max_consecutive_inactive_count() const;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  void clear_mip_check_precision() ;
  double mip_check_precision() const;
  void set_mip_check_precision(double value);
 
  private:
  double _internal_mip_check_precision() const;
  void _internal_set_mip_check_precision(double value);
 
  public:
  // optional int32 max_presolve_iterations = 138 [default = 3];
  bool has_max_presolve_iterations() const;
  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 exploit_objective = 131 [default = true];
  bool has_exploit_objective() const;
  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 catch_sigint_signal = 135 [default = true];
  bool has_catch_sigint_signal() const;
  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;
  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 add_lin_max_cuts = 152 [default = true];
  bool has_add_lin_max_cuts() const;
  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 double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  bool has_merge_no_overlap_work_limit() const;
  void clear_merge_no_overlap_work_limit() ;
  double merge_no_overlap_work_limit() const;
  void set_merge_no_overlap_work_limit(double value);
 
  private:
  double _internal_merge_no_overlap_work_limit() const;
  void _internal_set_merge_no_overlap_work_limit(double value);
 
  public:
  // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  bool has_merge_at_most_one_work_limit() const;
  void clear_merge_at_most_one_work_limit() ;
  double merge_at_most_one_work_limit() const;
  void set_merge_at_most_one_work_limit(double value);
 
  private:
  double _internal_merge_at_most_one_work_limit() const;
  void _internal_set_merge_at_most_one_work_limit(double value);
 
  public:
  // optional int32 presolve_substitution_level = 147 [default = 1];
  bool has_presolve_substitution_level() const;
  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 int32 max_all_diff_cut_size = 148 [default = 64];
  bool has_max_all_diff_cut_size() const;
  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;
  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 int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  bool has_max_cut_rounds_at_level_zero() const;
  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 double cut_max_active_count_value = 155 [default = 10000000000];
  bool has_cut_max_active_count_value() const;
  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 double cut_active_count_decay = 156 [default = 0.8];
  bool has_cut_active_count_decay() const;
  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;
  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 int32 cut_cleanup_target = 157 [default = 1000];
  bool has_cut_cleanup_target() const;
  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 .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  bool has_fp_rounding() const;
  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 bool use_sat_inprocessing = 163 [default = true];
  bool has_use_sat_inprocessing() const;
  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 use_feasibility_pump = 164 [default = true];
  bool has_use_feasibility_pump() const;
  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 mip_automatically_scale_variables = 166 [default = true];
  bool has_mip_automatically_scale_variables() const;
  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 add_zero_half_cuts = 169 [default = true];
  bool has_add_zero_half_cuts() const;
  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 int32 polarity_rephase_increment = 168 [default = 1000];
  bool has_polarity_rephase_increment() const;
  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 add_clique_cuts = 172 [default = true];
  bool has_add_clique_cuts() const;
  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 bool convert_intervals = 177 [default = true];
  bool has_convert_intervals() const;
  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 bool expand_reservoir_constraints = 182 [default = true];
  bool has_expand_reservoir_constraints() const;
  void clear_expand_reservoir_constraints() ;
  bool expand_reservoir_constraints() const;
  void set_expand_reservoir_constraints(bool value);
 
  private:
  bool _internal_expand_reservoir_constraints() const;
  void _internal_set_expand_reservoir_constraints(bool value);
 
  public:
  // optional bool log_to_stdout = 186 [default = true];
  bool has_log_to_stdout() const;
  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 int32 symmetry_level = 183 [default = 2];
  bool has_symmetry_level() const;
  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;
  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;
  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;
  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+20];
  bool has_mip_max_valid_magnitude() const;
  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:
  // optional int64 presolve_inclusion_work_limit = 201 [default = 100000000];
  bool has_presolve_inclusion_work_limit() const;
  void clear_presolve_inclusion_work_limit() ;
  ::int64_t presolve_inclusion_work_limit() const;
  void set_presolve_inclusion_work_limit(::int64_t value);
 
  private:
  ::int64_t _internal_presolve_inclusion_work_limit() const;
  void _internal_set_presolve_inclusion_work_limit(::int64_t value);
 
  public:
  // optional int32 cut_level = 196 [default = 1];
  bool has_cut_level() const;
  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 bool mip_compute_true_objective_bound = 198 [default = true];
  bool has_mip_compute_true_objective_bound() const;
  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 bool ignore_names = 202 [default = true];
  bool has_ignore_names() const;
  void clear_ignore_names() ;
  bool ignore_names() const;
  void set_ignore_names(bool value);
 
  private:
  bool _internal_ignore_names() const;
  void _internal_set_ignore_names(bool value);
 
  public:
  // optional bool share_binary_clauses = 203 [default = true];
  bool has_share_binary_clauses() const;
  void clear_share_binary_clauses() ;
  bool share_binary_clauses() const;
  void set_share_binary_clauses(bool value);
 
  private:
  bool _internal_share_binary_clauses() const;
  void _internal_set_share_binary_clauses(bool value);
 
  public:
  // optional bool use_dual_scheduling_heuristics = 214 [default = true];
  bool has_use_dual_scheduling_heuristics() const;
  void clear_use_dual_scheduling_heuristics() ;
  bool use_dual_scheduling_heuristics() const;
  void set_use_dual_scheduling_heuristics(bool value);
 
  private:
  bool _internal_use_dual_scheduling_heuristics() const;
  void _internal_set_use_dual_scheduling_heuristics(bool value);
 
  public:
  // optional double shaving_deterministic_time_in_probing_search = 204 [default = 0.001];
  bool has_shaving_deterministic_time_in_probing_search() const;
  void clear_shaving_deterministic_time_in_probing_search() ;
  double shaving_deterministic_time_in_probing_search() const;
  void set_shaving_deterministic_time_in_probing_search(double value);
 
  private:
  double _internal_shaving_deterministic_time_in_probing_search() const;
  void _internal_set_shaving_deterministic_time_in_probing_search(double value);
 
  public:
  // optional double shaving_search_deterministic_time = 205 [default = 0.1];
  bool has_shaving_search_deterministic_time() const;
  void clear_shaving_search_deterministic_time() ;
  double shaving_search_deterministic_time() const;
  void set_shaving_search_deterministic_time(double value);
 
  private:
  double _internal_shaving_search_deterministic_time() const;
  void _internal_set_shaving_search_deterministic_time(double value);
 
  public:
  // optional double propagation_loop_detection_factor = 221 [default = 10];
  bool has_propagation_loop_detection_factor() const;
  void clear_propagation_loop_detection_factor() ;
  double propagation_loop_detection_factor() const;
  void set_propagation_loop_detection_factor(double value);
 
  private:
  double _internal_propagation_loop_detection_factor() const;
  void _internal_set_propagation_loop_detection_factor(double value);
 
  public:
  // optional int32 table_compression_level = 217 [default = 2];
  bool has_table_compression_level() const;
  void clear_table_compression_level() ;
  ::int32_t table_compression_level() const;
  void set_table_compression_level(::int32_t value);
 
  private:
  ::int32_t _internal_table_compression_level() const;
  void _internal_set_table_compression_level(::int32_t value);
 
  public:
  // optional int32 root_lp_iterations = 227 [default = 2000];
  bool has_root_lp_iterations() const;
  void clear_root_lp_iterations() ;
  ::int32_t root_lp_iterations() const;
  void set_root_lp_iterations(::int32_t value);
 
  private:
  ::int32_t _internal_root_lp_iterations() const;
  void _internal_set_root_lp_iterations(::int32_t value);
 
  public:
  // optional double probing_deterministic_time_limit = 226 [default = 1];
  bool has_probing_deterministic_time_limit() const;
  void clear_probing_deterministic_time_limit() ;
  double probing_deterministic_time_limit() const;
  void set_probing_deterministic_time_limit(double value);
 
  private:
  double _internal_probing_deterministic_time_limit() const;
  void _internal_set_probing_deterministic_time_limit(double value);
 
  public:
  // optional double mip_drop_tolerance = 232 [default = 1e-16];
  bool has_mip_drop_tolerance() const;
  void clear_mip_drop_tolerance() ;
  double mip_drop_tolerance() const;
  void set_mip_drop_tolerance(double value);
 
  private:
  double _internal_mip_drop_tolerance() const;
  void _internal_set_mip_drop_tolerance(double value);
 
  public:
  // optional int32 max_size_to_create_precedence_literals_in_disjunctive = 229 [default = 60];
  bool has_max_size_to_create_precedence_literals_in_disjunctive() const;
  void clear_max_size_to_create_precedence_literals_in_disjunctive() ;
  ::int32_t max_size_to_create_precedence_literals_in_disjunctive() const;
  void set_max_size_to_create_precedence_literals_in_disjunctive(::int32_t value);
 
  private:
  ::int32_t _internal_max_size_to_create_precedence_literals_in_disjunctive() const;
  void _internal_set_max_size_to_create_precedence_literals_in_disjunctive(::int32_t value);
 
  public:
  // optional int32 shared_tree_num_workers = 235 [default = -1];
  bool has_shared_tree_num_workers() const;
  void clear_shared_tree_num_workers() ;
  ::int32_t shared_tree_num_workers() const;
  void set_shared_tree_num_workers(::int32_t value);
 
  private:
  ::int32_t _internal_shared_tree_num_workers() const;
  void _internal_set_shared_tree_num_workers(::int32_t value);
 
  public:
  // optional bool new_linear_propagation = 224 [default = true];
  bool has_new_linear_propagation() const;
  void clear_new_linear_propagation() ;
  bool new_linear_propagation() const;
  void set_new_linear_propagation(bool value);
 
  private:
  bool _internal_new_linear_propagation() const;
  void _internal_set_new_linear_propagation(bool value);
 
  public:
  // optional bool infer_all_diffs = 233 [default = true];
  bool has_infer_all_diffs() const;
  void clear_infer_all_diffs() ;
  bool infer_all_diffs() const;
  void set_infer_all_diffs(bool value);
 
  private:
  bool _internal_infer_all_diffs() const;
  void _internal_set_infer_all_diffs(bool value);
 
  public:
  // optional bool find_big_linear_overlap = 234 [default = true];
  bool has_find_big_linear_overlap() const;
  void clear_find_big_linear_overlap() ;
  bool find_big_linear_overlap() const;
  void set_find_big_linear_overlap(bool value);
 
  private:
  bool _internal_find_big_linear_overlap() const;
  void _internal_set_find_big_linear_overlap(bool value);
 
  public:
  // optional bool feasibility_jump_enable_restarts = 250 [default = true];
  bool has_feasibility_jump_enable_restarts() const;
  void clear_feasibility_jump_enable_restarts() ;
  bool feasibility_jump_enable_restarts() const;
  void set_feasibility_jump_enable_restarts(bool value);
 
  private:
  bool _internal_feasibility_jump_enable_restarts() const;
  void _internal_set_feasibility_jump_enable_restarts(bool value);
 
  public:
  // optional int32 shared_tree_max_nodes_per_worker = 238 [default = 10000];
  bool has_shared_tree_max_nodes_per_worker() const;
  void clear_shared_tree_max_nodes_per_worker() ;
  ::int32_t shared_tree_max_nodes_per_worker() const;
  void set_shared_tree_max_nodes_per_worker(::int32_t value);
 
  private:
  ::int32_t _internal_shared_tree_max_nodes_per_worker() const;
  void _internal_set_shared_tree_max_nodes_per_worker(::int32_t value);
 
  public:
  // optional double feasibility_jump_decay = 242 [default = 0.95];
  bool has_feasibility_jump_decay() const;
  void clear_feasibility_jump_decay() ;
  double feasibility_jump_decay() const;
  void set_feasibility_jump_decay(double value);
 
  private:
  double _internal_feasibility_jump_decay() const;
  void _internal_set_feasibility_jump_decay(double value);
 
  public:
  // optional double feasibility_jump_var_randomization_probability = 247 [default = 0.05];
  bool has_feasibility_jump_var_randomization_probability() const;
  void clear_feasibility_jump_var_randomization_probability() ;
  double feasibility_jump_var_randomization_probability() const;
  void set_feasibility_jump_var_randomization_probability(double value);
 
  private:
  double _internal_feasibility_jump_var_randomization_probability() const;
  void _internal_set_feasibility_jump_var_randomization_probability(double value);
 
  public:
  // optional double feasibility_jump_var_perburbation_range_ratio = 248 [default = 0.2];
  bool has_feasibility_jump_var_perburbation_range_ratio() const;
  void clear_feasibility_jump_var_perburbation_range_ratio() ;
  double feasibility_jump_var_perburbation_range_ratio() const;
  void set_feasibility_jump_var_perburbation_range_ratio(double value);
 
  private:
  double _internal_feasibility_jump_var_perburbation_range_ratio() const;
  void _internal_set_feasibility_jump_var_perburbation_range_ratio(double value);
 
  public:
  // optional int32 violation_ls_perturbation_period = 249 [default = 100];
  bool has_violation_ls_perturbation_period() const;
  void clear_violation_ls_perturbation_period() ;
  ::int32_t violation_ls_perturbation_period() const;
  void set_violation_ls_perturbation_period(::int32_t value);
 
  private:
  ::int32_t _internal_violation_ls_perturbation_period() const;
  void _internal_set_violation_ls_perturbation_period(::int32_t value);
 
  public:
  // optional int32 linear_split_size = 256 [default = 100];
  bool has_linear_split_size() const;
  void clear_linear_split_size() ;
  ::int32_t linear_split_size() const;
  void set_linear_split_size(::int32_t value);
 
  private:
  ::int32_t _internal_linear_split_size() const;
  void _internal_set_linear_split_size(::int32_t value);
 
  public:
  // optional int32 feasibility_jump_linearization_level = 257 [default = 2];
  bool has_feasibility_jump_linearization_level() const;
  void clear_feasibility_jump_linearization_level() ;
  ::int32_t feasibility_jump_linearization_level() const;
  void set_feasibility_jump_linearization_level(::int32_t value);
 
  private:
  ::int32_t _internal_feasibility_jump_linearization_level() const;
  void _internal_set_feasibility_jump_linearization_level(::int32_t value);
 
  public:
  // optional int32 feasibility_jump_restart_factor = 258 [default = 1];
  bool has_feasibility_jump_restart_factor() const;
  void clear_feasibility_jump_restart_factor() ;
  ::int32_t feasibility_jump_restart_factor() const;
  void set_feasibility_jump_restart_factor(::int32_t value);
 
  private:
  ::int32_t _internal_feasibility_jump_restart_factor() const;
  void _internal_set_feasibility_jump_restart_factor(::int32_t value);
 
  public:
  // optional double violation_ls_compound_move_probability = 259 [default = 0.5];
  bool has_violation_ls_compound_move_probability() const;
  void clear_violation_ls_compound_move_probability() ;
  double violation_ls_compound_move_probability() const;
  void set_violation_ls_compound_move_probability(double value);
 
  private:
  double _internal_violation_ls_compound_move_probability() const;
  void _internal_set_violation_ls_compound_move_probability(double value);
 
  public:
  // optional int32 max_num_intervals_for_timetable_edge_finding = 260 [default = 100];
  bool has_max_num_intervals_for_timetable_edge_finding() const;
  void clear_max_num_intervals_for_timetable_edge_finding() ;
  ::int32_t max_num_intervals_for_timetable_edge_finding() const;
  void set_max_num_intervals_for_timetable_edge_finding(::int32_t value);
 
  private:
  ::int32_t _internal_max_num_intervals_for_timetable_edge_finding() const;
  void _internal_set_max_num_intervals_for_timetable_edge_finding(::int32_t value);
 
  public:
  // optional int32 mip_presolve_level = 261 [default = 2];
  bool has_mip_presolve_level() const;
  void clear_mip_presolve_level() ;
  ::int32_t mip_presolve_level() const;
  void set_mip_presolve_level(::int32_t value);
 
  private:
  ::int32_t _internal_mip_presolve_level() const;
  void _internal_set_mip_presolve_level(::int32_t value);
 
  public:
  // optional double lp_primal_tolerance = 266 [default = 1e-07];
  bool has_lp_primal_tolerance() const;
  void clear_lp_primal_tolerance() ;
  double lp_primal_tolerance() const;
  void set_lp_primal_tolerance(double value);
 
  private:
  double _internal_lp_primal_tolerance() const;
  void _internal_set_lp_primal_tolerance(double value);
 
  public:
  // optional int32 feasibility_jump_max_expanded_constraint_size = 264 [default = 500];
  bool has_feasibility_jump_max_expanded_constraint_size() const;
  void clear_feasibility_jump_max_expanded_constraint_size() ;
  ::int32_t feasibility_jump_max_expanded_constraint_size() const;
  void set_feasibility_jump_max_expanded_constraint_size(::int32_t value);
 
  private:
  ::int32_t _internal_feasibility_jump_max_expanded_constraint_size() const;
  void _internal_set_feasibility_jump_max_expanded_constraint_size(::int32_t value);
 
  public:
  // optional bool use_lb_relax_lns = 255 [default = true];
  bool has_use_lb_relax_lns() const;
  void clear_use_lb_relax_lns() ;
  bool use_lb_relax_lns() const;
  void set_use_lb_relax_lns(bool value);
 
  private:
  bool _internal_use_lb_relax_lns() const;
  void _internal_set_use_lb_relax_lns(bool value);
 
  public:
  // optional bool use_feasibility_jump = 265 [default = true];
  bool has_use_feasibility_jump() const;
  void clear_use_feasibility_jump() ;
  bool use_feasibility_jump() const;
  void set_use_feasibility_jump(bool value);
 
  private:
  bool _internal_use_feasibility_jump() const;
  void _internal_set_use_feasibility_jump(bool value);
 
  public:
  // optional bool use_extended_probing = 269 [default = true];
  bool has_use_extended_probing() const;
  void clear_use_extended_probing() ;
  bool use_extended_probing() const;
  void set_use_extended_probing(bool value);
 
  private:
  bool _internal_use_extended_probing() const;
  void _internal_set_use_extended_probing(bool value);
 
  public:
  // optional bool add_rlt_cuts = 279 [default = true];
  bool has_add_rlt_cuts() const;
  void clear_add_rlt_cuts() ;
  bool add_rlt_cuts() const;
  void set_add_rlt_cuts(bool value);
 
  private:
  bool _internal_add_rlt_cuts() const;
  void _internal_set_add_rlt_cuts(bool value);
 
  public:
  // optional double lp_dual_tolerance = 267 [default = 1e-07];
  bool has_lp_dual_tolerance() const;
  void clear_lp_dual_tolerance() ;
  double lp_dual_tolerance() const;
  void set_lp_dual_tolerance(double value);
 
  private:
  double _internal_lp_dual_tolerance() const;
  void _internal_set_lp_dual_tolerance(double value);
 
  public:
  // optional int32 at_most_one_max_expansion_size = 270 [default = 3];
  bool has_at_most_one_max_expansion_size() const;
  void clear_at_most_one_max_expansion_size() ;
  ::int32_t at_most_one_max_expansion_size() const;
  void set_at_most_one_max_expansion_size(::int32_t value);
 
  private:
  ::int32_t _internal_at_most_one_max_expansion_size() const;
  void _internal_set_at_most_one_max_expansion_size(::int32_t value);
 
  public:
  // optional int32 probing_num_combinations_limit = 272 [default = 20000];
  bool has_probing_num_combinations_limit() const;
  void clear_probing_num_combinations_limit() ;
  ::int32_t probing_num_combinations_limit() const;
  void set_probing_num_combinations_limit(::int32_t value);
 
  private:
  ::int32_t _internal_probing_num_combinations_limit() const;
  void _internal_set_probing_num_combinations_limit(::int32_t value);
 
  public:
  // optional double inprocessing_dtime_ratio = 273 [default = 0.2];
  bool has_inprocessing_dtime_ratio() const;
  void clear_inprocessing_dtime_ratio() ;
  double inprocessing_dtime_ratio() const;
  void set_inprocessing_dtime_ratio(double value);
 
  private:
  double _internal_inprocessing_dtime_ratio() const;
  void _internal_set_inprocessing_dtime_ratio(double value);
 
  public:
  // optional double inprocessing_probing_dtime = 274 [default = 1];
  bool has_inprocessing_probing_dtime() const;
  void clear_inprocessing_probing_dtime() ;
  double inprocessing_probing_dtime() const;
  void set_inprocessing_probing_dtime(double value);
 
  private:
  double _internal_inprocessing_probing_dtime() const;
  void _internal_set_inprocessing_probing_dtime(double value);
 
  public:
  // optional double inprocessing_minimization_dtime = 275 [default = 1];
  bool has_inprocessing_minimization_dtime() const;
  void clear_inprocessing_minimization_dtime() ;
  double inprocessing_minimization_dtime() const;
  void set_inprocessing_minimization_dtime(double value);
 
  private:
  double _internal_inprocessing_minimization_dtime() const;
  void _internal_set_inprocessing_minimization_dtime(double value);
 
  public:
  // optional int32 max_pairs_pairwise_reasoning_in_no_overlap_2d = 276 [default = 1250];
  bool has_max_pairs_pairwise_reasoning_in_no_overlap_2d() const;
  void clear_max_pairs_pairwise_reasoning_in_no_overlap_2d() ;
  ::int32_t max_pairs_pairwise_reasoning_in_no_overlap_2d() const;
  void set_max_pairs_pairwise_reasoning_in_no_overlap_2d(::int32_t value);
 
  private:
  ::int32_t _internal_max_pairs_pairwise_reasoning_in_no_overlap_2d() const;
  void _internal_set_max_pairs_pairwise_reasoning_in_no_overlap_2d(::int32_t value);
 
  public:
  // optional int32 shared_tree_worker_min_restarts_per_subtree = 282 [default = 1];
  bool has_shared_tree_worker_min_restarts_per_subtree() const;
  void clear_shared_tree_worker_min_restarts_per_subtree() ;
  ::int32_t shared_tree_worker_min_restarts_per_subtree() const;
  void set_shared_tree_worker_min_restarts_per_subtree(::int32_t value);
 
  private:
  ::int32_t _internal_shared_tree_worker_min_restarts_per_subtree() const;
  void _internal_set_shared_tree_worker_min_restarts_per_subtree(::int32_t value);
 
  public:
  // optional double shared_tree_open_leaves_per_worker = 281 [default = 2];
  bool has_shared_tree_open_leaves_per_worker() const;
  void clear_shared_tree_open_leaves_per_worker() ;
  double shared_tree_open_leaves_per_worker() const;
  void set_shared_tree_open_leaves_per_worker(double value);
 
  private:
  double _internal_shared_tree_open_leaves_per_worker() const;
  void _internal_set_shared_tree_open_leaves_per_worker(double value);
 
  public:
  // optional int32 variables_shaving_level = 289 [default = -1];
  bool has_variables_shaving_level() const;
  void clear_variables_shaving_level() ;
  ::int32_t variables_shaving_level() const;
  void set_variables_shaving_level(::int32_t value);
 
  private:
  ::int32_t _internal_variables_shaving_level() const;
  void _internal_set_variables_shaving_level(::int32_t value);
 
  public:
  // optional bool use_lns = 283 [default = true];
  bool has_use_lns() const;
  void clear_use_lns() ;
  bool use_lns() const;
  void set_use_lns(bool value);
 
  private:
  bool _internal_use_lns() const;
  void _internal_set_use_lns(bool value);
 
  public:
  // optional bool share_glue_clauses = 285 [default = true];
  bool has_share_glue_clauses() const;
  void clear_share_glue_clauses() ;
  bool share_glue_clauses() const;
  void set_share_glue_clauses(bool value);
 
  private:
  bool _internal_share_glue_clauses() const;
  void _internal_set_share_glue_clauses(bool value);
 
  public:
  // optional bool shared_tree_worker_enable_trail_sharing = 295 [default = true];
  bool has_shared_tree_worker_enable_trail_sharing() const;
  void clear_shared_tree_worker_enable_trail_sharing() ;
  bool shared_tree_worker_enable_trail_sharing() const;
  void set_shared_tree_worker_enable_trail_sharing(bool value);
 
  private:
  bool _internal_shared_tree_worker_enable_trail_sharing() const;
  void _internal_set_shared_tree_worker_enable_trail_sharing(bool value);
 
  public:
  // optional bool inprocessing_minimization_use_conflict_analysis = 297 [default = true];
  bool has_inprocessing_minimization_use_conflict_analysis() const;
  void clear_inprocessing_minimization_use_conflict_analysis() ;
  bool inprocessing_minimization_use_conflict_analysis() const;
  void set_inprocessing_minimization_use_conflict_analysis(bool value);
 
  private:
  bool _internal_inprocessing_minimization_use_conflict_analysis() const;
  void _internal_set_inprocessing_minimization_use_conflict_analysis(bool value);
 
  public:
  // optional int64 shaving_search_threshold = 290 [default = 64];
  bool has_shaving_search_threshold() const;
  void clear_shaving_search_threshold() ;
  ::int64_t shaving_search_threshold() const;
  void set_shaving_search_threshold(::int64_t value);
 
  private:
  ::int64_t _internal_shaving_search_threshold() const;
  void _internal_set_shaving_search_threshold(::int64_t value);
 
  public:
  // optional double feasibility_jump_batch_dtime = 292 [default = 0.1];
  bool has_feasibility_jump_batch_dtime() const;
  void clear_feasibility_jump_batch_dtime() ;
  double feasibility_jump_batch_dtime() const;
  void set_feasibility_jump_batch_dtime(double value);
 
  private:
  double _internal_feasibility_jump_batch_dtime() const;
  void _internal_set_feasibility_jump_batch_dtime(double value);
 
  public:
  // optional int32 lb_relax_num_workers_threshold = 296 [default = 16];
  bool has_lb_relax_num_workers_threshold() const;
  void clear_lb_relax_num_workers_threshold() ;
  ::int32_t lb_relax_num_workers_threshold() const;
  void set_lb_relax_num_workers_threshold(::int32_t value);
 
  private:
  ::int32_t _internal_lb_relax_num_workers_threshold() const;
  void _internal_set_lb_relax_num_workers_threshold(::int32_t value);
 
  public:
  // optional int32 shared_tree_balance_tolerance = 305 [default = 1];
  bool has_shared_tree_balance_tolerance() const;
  void clear_shared_tree_balance_tolerance() ;
  ::int32_t shared_tree_balance_tolerance() const;
  void set_shared_tree_balance_tolerance(::int32_t value);
 
  private:
  ::int32_t _internal_shared_tree_balance_tolerance() const;
  void _internal_set_shared_tree_balance_tolerance(::int32_t value);
 
  public:
  // optional double symmetry_detection_deterministic_time_limit = 302 [default = 1];
  bool has_symmetry_detection_deterministic_time_limit() const;
  void clear_symmetry_detection_deterministic_time_limit() ;
  double symmetry_detection_deterministic_time_limit() const;
  void set_symmetry_detection_deterministic_time_limit(double value);
 
  private:
  double _internal_symmetry_detection_deterministic_time_limit() const;
  void _internal_set_symmetry_detection_deterministic_time_limit(double value);
 
  public:
  // optional double lns_initial_difficulty = 307 [default = 0.5];
  bool has_lns_initial_difficulty() const;
  void clear_lns_initial_difficulty() ;
  double lns_initial_difficulty() const;
  void set_lns_initial_difficulty(double value);
 
  private:
  double _internal_lns_initial_difficulty() const;
  void _internal_set_lns_initial_difficulty(double value);
 
  public:
  // optional double lns_initial_deterministic_limit = 308 [default = 0.1];
  bool has_lns_initial_deterministic_limit() const;
  void clear_lns_initial_deterministic_limit() ;
  double lns_initial_deterministic_limit() const;
  void set_lns_initial_deterministic_limit(double value);
 
  private:
  double _internal_lns_initial_deterministic_limit() const;
  void _internal_set_lns_initial_deterministic_limit(double value);
 
  public:
  // optional bool minimize_shared_clauses = 300 [default = true];
  bool has_minimize_shared_clauses() const;
  void clear_minimize_shared_clauses() ;
  bool minimize_shared_clauses() const;
  void set_minimize_shared_clauses(bool value);
 
  private:
  bool _internal_minimize_shared_clauses() const;
  void _internal_set_minimize_shared_clauses(bool value);
 
  public:
  // optional bool shared_tree_worker_enable_phase_sharing = 304 [default = true];
  bool has_shared_tree_worker_enable_phase_sharing() const;
  void clear_shared_tree_worker_enable_phase_sharing() ;
  bool shared_tree_worker_enable_phase_sharing() const;
  void set_shared_tree_worker_enable_phase_sharing(bool value);
 
  private:
  bool _internal_shared_tree_worker_enable_phase_sharing() const;
  void _internal_set_shared_tree_worker_enable_phase_sharing(bool value);
 
  public:
  // optional bool remove_fixed_variables_early = 310 [default = true];
  bool has_remove_fixed_variables_early() const;
  void clear_remove_fixed_variables_early() ;
  bool remove_fixed_variables_early() const;
  void set_remove_fixed_variables_early(bool value);
 
  private:
  bool _internal_remove_fixed_variables_early() const;
  void _internal_set_remove_fixed_variables_early(bool value);
 
  public:
  // optional bool use_linear3_for_no_overlap_2d_precedences = 323 [default = true];
  bool has_use_linear3_for_no_overlap_2d_precedences() const;
  void clear_use_linear3_for_no_overlap_2d_precedences() ;
  bool use_linear3_for_no_overlap_2d_precedences() const;
  void set_use_linear3_for_no_overlap_2d_precedences(bool value);
 
  private:
  bool _internal_use_linear3_for_no_overlap_2d_precedences() const;
  void _internal_set_use_linear3_for_no_overlap_2d_precedences(bool value);
 
  public:
  // optional int32 routing_cut_subset_size_for_exact_binary_relation_bound = 316 [default = 8];
  bool has_routing_cut_subset_size_for_exact_binary_relation_bound() const;
  void clear_routing_cut_subset_size_for_exact_binary_relation_bound() ;
  ::int32_t routing_cut_subset_size_for_exact_binary_relation_bound() const;
  void set_routing_cut_subset_size_for_exact_binary_relation_bound(::int32_t value);
 
  private:
  ::int32_t _internal_routing_cut_subset_size_for_exact_binary_relation_bound() const;
  void _internal_set_routing_cut_subset_size_for_exact_binary_relation_bound(::int32_t value);
 
  public:
  // optional double routing_cut_dp_effort = 314 [default = 10000000];
  bool has_routing_cut_dp_effort() const;
  void clear_routing_cut_dp_effort() ;
  double routing_cut_dp_effort() const;
  void set_routing_cut_dp_effort(double value);
 
  private:
  double _internal_routing_cut_dp_effort() const;
  void _internal_set_routing_cut_dp_effort(double value);
 
  public:
  // optional int32 routing_cut_max_infeasible_path_length = 317 [default = 6];
  bool has_routing_cut_max_infeasible_path_length() const;
  void clear_routing_cut_max_infeasible_path_length() ;
  ::int32_t routing_cut_max_infeasible_path_length() const;
  void set_routing_cut_max_infeasible_path_length(::int32_t value);
 
  private:
  ::int32_t _internal_routing_cut_max_infeasible_path_length() const;
  void _internal_set_routing_cut_max_infeasible_path_length(::int32_t value);
 
  public:
  // optional int32 routing_cut_subset_size_for_shortest_paths_bound = 318 [default = 8];
  bool has_routing_cut_subset_size_for_shortest_paths_bound() const;
  void clear_routing_cut_subset_size_for_shortest_paths_bound() ;
  ::int32_t routing_cut_subset_size_for_shortest_paths_bound() const;
  void set_routing_cut_subset_size_for_shortest_paths_bound(::int32_t value);
 
  private:
  ::int32_t _internal_routing_cut_subset_size_for_shortest_paths_bound() const;
  void _internal_set_routing_cut_subset_size_for_shortest_paths_bound(::int32_t value);
 
  public:
  // optional int32 max_alldiff_domain_size = 320 [default = 256];
  bool has_max_alldiff_domain_size() const;
  void clear_max_alldiff_domain_size() ;
  ::int32_t max_alldiff_domain_size() const;
  void set_max_alldiff_domain_size(::int32_t value);
 
  private:
  ::int32_t _internal_max_alldiff_domain_size() const;
  void _internal_set_max_alldiff_domain_size(::int32_t value);
 
  public:
  // optional int32 no_overlap_2d_boolean_relations_limit = 321 [default = 10];
  bool has_no_overlap_2d_boolean_relations_limit() const;
  void clear_no_overlap_2d_boolean_relations_limit() ;
  ::int32_t no_overlap_2d_boolean_relations_limit() const;
  void set_no_overlap_2d_boolean_relations_limit(::int32_t value);
 
  private:
  ::int32_t _internal_no_overlap_2d_boolean_relations_limit() const;
  void _internal_set_no_overlap_2d_boolean_relations_limit(::int32_t value);
 
  public:
  // optional double share_glue_clauses_dtime = 322 [default = 1];
  bool has_share_glue_clauses_dtime() const;
  void clear_share_glue_clauses_dtime() ;
  double share_glue_clauses_dtime() const;
  void set_share_glue_clauses_dtime(double value);
 
  private:
  double _internal_share_glue_clauses_dtime() const;
  void _internal_set_share_glue_clauses_dtime(double value);
 
  public:
  // optional int32 alternative_pool_size = 325 [default = 1];
  bool has_alternative_pool_size() const;
  void clear_alternative_pool_size() ;
  ::int32_t alternative_pool_size() const;
  void set_alternative_pool_size(::int32_t value);
 
  private:
  ::int32_t _internal_alternative_pool_size() const;
  void _internal_set_alternative_pool_size(::int32_t value);
 
  public:
  // optional int32 transitive_precedences_work_limit = 327 [default = 1000000];
  bool has_transitive_precedences_work_limit() const;
  void clear_transitive_precedences_work_limit() ;
  ::int32_t transitive_precedences_work_limit() const;
  void set_transitive_precedences_work_limit(::int32_t value);
 
  private:
  ::int32_t _internal_transitive_precedences_work_limit() const;
  void _internal_set_transitive_precedences_work_limit(::int32_t value);
 
  public:
  // optional double shared_tree_split_min_dtime = 328 [default = 0.1];
  bool has_shared_tree_split_min_dtime() const;
  void clear_shared_tree_split_min_dtime() ;
  double shared_tree_split_min_dtime() const;
  void set_shared_tree_split_min_dtime(double value);
 
  private:
  double _internal_shared_tree_split_min_dtime() const;
  void _internal_set_shared_tree_split_min_dtime(double value);
 
  public:
  // optional int32 solution_pool_diversity_limit = 329 [default = 10];
  bool has_solution_pool_diversity_limit() const;
  void clear_solution_pool_diversity_limit() ;
  ::int32_t solution_pool_diversity_limit() const;
  void set_solution_pool_diversity_limit(::int32_t value);
 
  private:
  ::int32_t _internal_solution_pool_diversity_limit() const;
  void _internal_set_solution_pool_diversity_limit(::int32_t value);
 
  public:
  // optional int32 max_backjump_levels = 331 [default = 50];
  bool has_max_backjump_levels() const;
  void clear_max_backjump_levels() ;
  ::int32_t max_backjump_levels() const;
  void set_max_backjump_levels(::int32_t value);
 
  private:
  ::int32_t _internal_max_backjump_levels() const;
  void _internal_set_max_backjump_levels(::int32_t value);
 
  public:
  // optional int32 chronological_backtrack_min_conflicts = 332 [default = 1000];
  bool has_chronological_backtrack_min_conflicts() const;
  void clear_chronological_backtrack_min_conflicts() ;
  ::int32_t chronological_backtrack_min_conflicts() const;
  void set_chronological_backtrack_min_conflicts(::int32_t value);
 
  private:
  ::int32_t _internal_chronological_backtrack_min_conflicts() const;
  void _internal_set_chronological_backtrack_min_conflicts(::int32_t value);
 
  public:
  // optional int32 max_domain_size_for_linear2_expansion = 340 [default = 8];
  bool has_max_domain_size_for_linear2_expansion() const;
  void clear_max_domain_size_for_linear2_expansion() ;
  ::int32_t max_domain_size_for_linear2_expansion() const;
  void set_max_domain_size_for_linear2_expansion(::int32_t value);
 
  private:
  ::int32_t _internal_max_domain_size_for_linear2_expansion() const;
  void _internal_set_max_domain_size_for_linear2_expansion(::int32_t value);
 
  public:
  // optional bool find_clauses_that_are_exactly_one = 333 [default = true];
  bool has_find_clauses_that_are_exactly_one() const;
  void clear_find_clauses_that_are_exactly_one() ;
  bool find_clauses_that_are_exactly_one() const;
  void set_find_clauses_that_are_exactly_one(bool value);
 
  private:
  bool _internal_find_clauses_that_are_exactly_one() const;
  void _internal_set_find_clauses_that_are_exactly_one(bool value);
 
  public:
  // optional bool create_1uip_boolean_during_icr = 341 [default = true];
  bool has_create_1uip_boolean_during_icr() const;
  void clear_create_1uip_boolean_during_icr() ;
  bool create_1uip_boolean_during_icr() const;
  void set_create_1uip_boolean_during_icr(bool value);
 
  private:
  bool _internal_create_1uip_boolean_during_icr() const;
  void _internal_set_create_1uip_boolean_during_icr(bool value);
 
  public:
  // optional bool inprocessing_use_congruence_closure = 342 [default = true];
  bool has_inprocessing_use_congruence_closure() const;
  void clear_inprocessing_use_congruence_closure() ;
  bool inprocessing_use_congruence_closure() const;
  void set_inprocessing_use_congruence_closure(bool value);
 
  private:
  bool _internal_inprocessing_use_congruence_closure() const;
  void _internal_set_inprocessing_use_congruence_closure(bool value);
 
  public:
  // optional bool extra_subsumption_during_conflict_analysis = 351 [default = true];
  bool has_extra_subsumption_during_conflict_analysis() const;
  void clear_extra_subsumption_during_conflict_analysis() ;
  bool extra_subsumption_during_conflict_analysis() const;
  void set_extra_subsumption_during_conflict_analysis(bool value);
 
  private:
  bool _internal_extra_subsumption_during_conflict_analysis() const;
  void _internal_set_extra_subsumption_during_conflict_analysis(bool value);
 
  public:
  // optional int32 eagerly_subsume_last_n_conflicts = 343 [default = 4];
  bool has_eagerly_subsume_last_n_conflicts() const;
  void clear_eagerly_subsume_last_n_conflicts() ;
  ::int32_t eagerly_subsume_last_n_conflicts() const;
  void set_eagerly_subsume_last_n_conflicts(::int32_t value);
 
  private:
  ::int32_t _internal_eagerly_subsume_last_n_conflicts() const;
  void _internal_set_eagerly_subsume_last_n_conflicts(::int32_t value);
 
  public:
  // optional double max_drat_time_in_seconds = 348 [default = inf];
  bool has_max_drat_time_in_seconds() const;
  void clear_max_drat_time_in_seconds() ;
  double max_drat_time_in_seconds() const;
  void set_max_drat_time_in_seconds(double value);
 
  private:
  double _internal_max_drat_time_in_seconds() const;
  void _internal_set_max_drat_time_in_seconds(double value);
 
  public:
  // optional bool decision_subsumption_during_conflict_analysis = 353 [default = true];
  bool has_decision_subsumption_during_conflict_analysis() const;
  void clear_decision_subsumption_during_conflict_analysis() ;
  bool decision_subsumption_during_conflict_analysis() const;
  void set_decision_subsumption_during_conflict_analysis(bool value);
 
  private:
  bool _internal_decision_subsumption_during_conflict_analysis() const;
  void _internal_set_decision_subsumption_during_conflict_analysis(bool value);
 
  public:
  // optional bool subsume_during_vivification = 355 [default = true];
  bool has_subsume_during_vivification() const;
  void clear_subsume_during_vivification() ;
  bool subsume_during_vivification() const;
  void set_subsume_during_vivification(bool value);
 
  private:
  bool _internal_subsume_during_vivification() const;
  void _internal_set_subsume_during_vivification(bool value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.sat.SatParameters)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<5, 303,
                                   12, 0,
                                   47>
      _table_;
 
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SatParameters& from_msg);
    ::google::protobuf::internal::HasBits<10> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int preferred_variable_order_;
    ::int32_t clause_cleanup_target_;
    double random_polarity_ratio_;
    bool log_search_progress_;
    bool use_pb_resolution_;
    bool use_optimization_hints_;
    bool use_phase_saving_;
    bool use_precedences_in_disjunctive_constraint_;
    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_;
    ::google::protobuf::RepeatedField<int> restart_algorithms_;
    ::google::protobuf::RepeatedPtrField<::std::string> subsolvers_;
    ::google::protobuf::RepeatedPtrField<::std::string> ignore_subsolvers_;
    ::google::protobuf::RepeatedPtrField< ::operations_research::sat::SatParameters > subsolver_params_;
    ::google::protobuf::RepeatedPtrField<::std::string> extra_subsolvers_;
    ::google::protobuf::RepeatedPtrField<::std::string> filter_subsolvers_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_default_restart_algorithms_;
    ::google::protobuf::internal::ArenaStringPtr default_restart_algorithms_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr log_prefix_;
    double random_branches_ratio_;
    int max_sat_assumption_order_;
    bool minimize_reduction_during_pb_resolution_;
    bool max_sat_reverse_assumption_order_;
    bool use_blocking_restart_;
    bool use_erwa_heuristic_;
    int clause_cleanup_ordering_;
    ::int32_t num_conflicts_before_strategy_changes_;
    double strategy_change_increase_ratio_;
    double initial_variables_activity_;
    bool also_bump_variables_in_conflict_reasons_;
    bool use_overload_checker_in_cumulative_;
    bool use_timetable_edge_finding_in_cumulative_;
    bool optimize_with_core_;
    int search_branching_;
    bool optimize_with_max_hs_;
    bool enumerate_all_solutions_;
    bool only_add_cuts_at_level_zero_;
    bool stop_after_first_solution_;
    ::int32_t num_search_workers_;
    ::int64_t search_random_variable_pool_size_;
    bool use_lns_only_;
    bool randomize_search_;
    bool use_optional_variables_;
    bool exploit_best_solution_;
    ::int32_t interleave_batch_size_;
    bool fill_tightened_domains_in_response_;
    bool use_combined_no_overlap_;
    bool interleave_search_;
    bool diversify_lns_params_;
    ::int32_t debug_max_num_presolve_operations_;
    double relative_gap_limit_;
    bool stop_after_presolve_;
    bool exploit_relaxation_solution_;
    bool debug_postsolve_with_full_solver_;
    bool repair_hint_;
    bool expand_alldiff_constraints_;
    bool keep_all_feasible_solutions_in_presolve_;
    bool presolve_extract_integer_enforcement_;
    bool polish_lp_solution_;
    bool use_probing_search_;
    bool permute_variable_randomly_;
    bool permute_presolve_constraint_order_;
    bool use_absl_random_;
    bool disable_constraint_expansion_;
    bool log_to_response_;
    bool optimize_with_lb_tree_search_;
    bool log_subsolver_statistics_;
    bool fix_variables_to_their_hinted_value_;
    bool fill_additional_solutions_in_response_;
    bool debug_crash_on_bad_hint_;
    bool add_objective_cut_;
    ::int32_t num_workers_;
    bool use_timetabling_in_no_overlap_2d_;
    bool use_energetic_reasoning_in_no_overlap_2d_;
    bool use_hard_precedences_in_cumulative_;
    bool detect_table_with_cost_;
    bool exploit_all_precedences_;
    bool only_solve_ip_;
    bool encode_complex_linear_constraint_with_integer_;
    bool mip_scale_large_domain_;
    bool use_objective_lb_search_;
    bool use_strong_propagation_in_disjunctive_;
    bool use_shared_tree_search_;
    bool use_ls_only_;
    int shared_tree_split_strategy_;
    ::int32_t num_violation_ls_;
    bool stop_after_root_propagation_;
    bool use_objective_shaving_search_;
    bool push_all_tasks_toward_start_;
    bool use_dynamic_precedence_in_disjunctive_;
    bool use_dynamic_precedence_in_cumulative_;
    bool use_area_energetic_reasoning_in_no_overlap_2d_;
    bool detect_linearized_product_;
    bool mip_treat_high_magnitude_bounds_as_infinity_;
    ::int32_t max_lin_max_size_for_expansion_;
    bool save_lp_basis_in_lb_tree_search_;
    bool use_conservative_scale_overload_checker_;
    bool encode_cumulative_as_reservoir_;
    bool expand_reservoir_using_circuit_;
    ::int32_t max_num_deterministic_batches_;
    ::int32_t num_full_subsolvers_;
    bool inprocessing_minimization_use_all_orderings_;
    bool use_try_edge_reasoning_in_no_overlap_2d_;
    bool use_symmetry_in_lp_;
    bool keep_symmetry_in_presolve_;
    ::int32_t routing_cut_subset_size_for_binary_relation_bound_;
    bool debug_crash_if_presolve_breaks_hint_;
    bool polarity_exploit_ls_hints_;
    bool use_all_different_for_circuit_;
    bool filter_sat_postsolve_clauses_;
    ::int32_t routing_cut_subset_size_for_tight_binary_relation_bound_;
    ::int32_t maximum_regions_to_split_in_disconnected_no_overlap_2d_;
    bool share_linear2_bounds_;
    bool use_chronological_backtracking_;
    bool load_at_most_ones_in_sat_presolve_;
    bool use_new_integer_conflict_resolution_;
    ::int32_t clause_cleanup_period_increment_;
    bool debug_crash_if_lrat_check_fails_;
    bool check_lrat_proof_;
    bool output_lrat_proof_;
    bool check_drat_proof_;
    ::int32_t clause_cleanup_lbd_tier1_;
    ::int32_t clause_cleanup_lbd_tier2_;
    bool output_drat_proof_;
    bool check_merged_lrat_proof_;
    bool inprocessing_use_sat_sweeping_;
    ::int64_t max_memory_in_mb_;
    int binary_minimization_algorithm_;
    ::int32_t pb_cleanup_increment_;
    double pb_cleanup_ratio_;
    ::int32_t core_minimization_level_;
    int max_sat_stratification_;
    ::int32_t presolve_bve_threshold_;
    ::int32_t presolve_bve_clause_weight_;
    double presolve_probing_deterministic_time_limit_;
    ::int32_t clause_cleanup_lbd_bound_;
    ::int32_t restart_running_window_size_;
    double restart_dl_average_ratio_;
    bool count_assumption_levels_in_lbd_;
    bool subsumption_during_conflict_analysis_;
    bool presolve_use_bva_;
    bool use_disjunctive_constraint_in_cumulative_;
    ::int32_t blocking_restart_window_size_;
    double blocking_restart_multiplier_;
    double max_deterministic_time_;
    double restart_lbd_average_ratio_;
    ::int32_t presolve_bva_threshold_;
    bool find_multiple_cores_;
    bool cp_model_presolve_;
    bool presolve_blocked_clause_;
    bool cover_optimization_;
    ::int32_t linearization_level_;
    ::int32_t max_num_cuts_;
    bool cp_model_use_sat_presolve_;
    bool exploit_integer_lp_solution_;
    bool auto_detect_greater_than_at_least_one_of_;
    bool instantiate_all_variables_;
    ::int32_t binary_search_num_conflicts_;
    ::int32_t boolean_encoding_level_;
    ::int32_t cp_model_probing_level_;
    bool use_exact_lp_reason_;
    bool add_lp_constraints_lazily_;
    bool share_objective_bounds_;
    bool share_level_zero_bounds_;
    ::int32_t max_integer_rounding_scaling_;
    double min_orthogonality_for_lp_constraints_;
    bool exploit_all_lp_solution_;
    bool add_cg_cuts_;
    bool add_mir_cuts_;
    bool use_rins_lns_;
    ::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_;
    ::int32_t max_presolve_iterations_;
    bool exploit_objective_;
    bool catch_sigint_signal_;
    bool use_implied_bounds_;
    bool add_lin_max_cuts_;
    double merge_no_overlap_work_limit_;
    double merge_at_most_one_work_limit_;
    ::int32_t presolve_substitution_level_;
    ::int32_t max_all_diff_cut_size_;
    ::int32_t hint_conflict_limit_;
    ::int32_t max_cut_rounds_at_level_zero_;
    double cut_max_active_count_value_;
    double cut_active_count_decay_;
    double absolute_gap_limit_;
    ::int32_t cut_cleanup_target_;
    int fp_rounding_;
    bool use_sat_inprocessing_;
    bool use_feasibility_pump_;
    bool mip_automatically_scale_variables_;
    bool add_zero_half_cuts_;
    ::int32_t polarity_rephase_increment_;
    bool add_clique_cuts_;
    bool convert_intervals_;
    bool expand_reservoir_constraints_;
    bool log_to_stdout_;
    ::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_;
    ::int64_t presolve_inclusion_work_limit_;
    ::int32_t cut_level_;
    bool mip_compute_true_objective_bound_;
    bool ignore_names_;
    bool share_binary_clauses_;
    bool use_dual_scheduling_heuristics_;
    double shaving_deterministic_time_in_probing_search_;
    double shaving_search_deterministic_time_;
    double propagation_loop_detection_factor_;
    ::int32_t table_compression_level_;
    ::int32_t root_lp_iterations_;
    double probing_deterministic_time_limit_;
    double mip_drop_tolerance_;
    ::int32_t max_size_to_create_precedence_literals_in_disjunctive_;
    ::int32_t shared_tree_num_workers_;
    bool new_linear_propagation_;
    bool infer_all_diffs_;
    bool find_big_linear_overlap_;
    bool feasibility_jump_enable_restarts_;
    ::int32_t shared_tree_max_nodes_per_worker_;
    double feasibility_jump_decay_;
    double feasibility_jump_var_randomization_probability_;
    double feasibility_jump_var_perburbation_range_ratio_;
    ::int32_t violation_ls_perturbation_period_;
    ::int32_t linear_split_size_;
    ::int32_t feasibility_jump_linearization_level_;
    ::int32_t feasibility_jump_restart_factor_;
    double violation_ls_compound_move_probability_;
    ::int32_t max_num_intervals_for_timetable_edge_finding_;
    ::int32_t mip_presolve_level_;
    double lp_primal_tolerance_;
    ::int32_t feasibility_jump_max_expanded_constraint_size_;
    bool use_lb_relax_lns_;
    bool use_feasibility_jump_;
    bool use_extended_probing_;
    bool add_rlt_cuts_;
    double lp_dual_tolerance_;
    ::int32_t at_most_one_max_expansion_size_;
    ::int32_t probing_num_combinations_limit_;
    double inprocessing_dtime_ratio_;
    double inprocessing_probing_dtime_;
    double inprocessing_minimization_dtime_;
    ::int32_t max_pairs_pairwise_reasoning_in_no_overlap_2d_;
    ::int32_t shared_tree_worker_min_restarts_per_subtree_;
    double shared_tree_open_leaves_per_worker_;
    ::int32_t variables_shaving_level_;
    bool use_lns_;
    bool share_glue_clauses_;
    bool shared_tree_worker_enable_trail_sharing_;
    bool inprocessing_minimization_use_conflict_analysis_;
    ::int64_t shaving_search_threshold_;
    double feasibility_jump_batch_dtime_;
    ::int32_t lb_relax_num_workers_threshold_;
    ::int32_t shared_tree_balance_tolerance_;
    double symmetry_detection_deterministic_time_limit_;
    double lns_initial_difficulty_;
    double lns_initial_deterministic_limit_;
    bool minimize_shared_clauses_;
    bool shared_tree_worker_enable_phase_sharing_;
    bool remove_fixed_variables_early_;
    bool use_linear3_for_no_overlap_2d_precedences_;
    ::int32_t routing_cut_subset_size_for_exact_binary_relation_bound_;
    double routing_cut_dp_effort_;
    ::int32_t routing_cut_max_infeasible_path_length_;
    ::int32_t routing_cut_subset_size_for_shortest_paths_bound_;
    ::int32_t max_alldiff_domain_size_;
    ::int32_t no_overlap_2d_boolean_relations_limit_;
    double share_glue_clauses_dtime_;
    ::int32_t alternative_pool_size_;
    ::int32_t transitive_precedences_work_limit_;
    double shared_tree_split_min_dtime_;
    ::int32_t solution_pool_diversity_limit_;
    ::int32_t max_backjump_levels_;
    ::int32_t chronological_backtrack_min_conflicts_;
    ::int32_t max_domain_size_for_linear2_expansion_;
    bool find_clauses_that_are_exactly_one_;
    bool create_1uip_boolean_during_icr_;
    bool inprocessing_use_congruence_closure_;
    bool extra_subsumption_during_conflict_analysis_;
    ::int32_t eagerly_subsume_last_n_conflicts_;
    double max_drat_time_in_seconds_;
    bool decision_subsumption_during_conflict_analysis_;
    bool subsume_during_vivification_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SatParameters_class_data_;
 
// ===================================================================
 
 
 
 
// ===================================================================
 
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// SatParameters
 
// optional string name = 171 [default = ""];
inline bool SatParameters::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x20000000U);
  return value;
}
inline void SatParameters::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x20000000U);
}
inline const ::std::string& SatParameters::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SatParameters::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.name)
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  ::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 {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void SatParameters::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SatParameters::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x20000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void SatParameters::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@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::has_preferred_variable_order() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void SatParameters::clear_preferred_variable_order() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.preferred_variable_order_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
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::set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value) {
  _internal_set_preferred_variable_order(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.preferred_variable_order)
}
inline ::operations_research::sat::SatParameters_VariableOrder SatParameters::_internal_preferred_variable_order() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_VariableOrder>(_impl_.preferred_variable_order_);
}
inline void SatParameters::_internal_set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_VariableOrder_internal_data_));
                                          _impl_.preferred_variable_order_ = value;
}
 
// optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
inline bool SatParameters::has_initial_polarity() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void SatParameters::clear_initial_polarity() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initial_polarity_ = 1;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000100U);
}
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::set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
  _internal_set_initial_polarity(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.initial_polarity)
}
inline ::operations_research::sat::SatParameters_Polarity SatParameters::_internal_initial_polarity() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_Polarity>(_impl_.initial_polarity_);
}
inline void SatParameters::_internal_set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_Polarity_internal_data_));
                                          _impl_.initial_polarity_ = value;
}
 
// optional bool use_phase_saving = 44 [default = true];
inline bool SatParameters::has_use_phase_saving() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void SatParameters::clear_use_phase_saving() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_phase_saving_ = true;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000040U);
}
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::set_use_phase_saving(bool value) {
  _internal_set_use_phase_saving(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_phase_saving)
}
inline bool SatParameters::_internal_use_phase_saving() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_phase_saving_;
}
inline void SatParameters::_internal_set_use_phase_saving(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_phase_saving_ = value;
}
 
// optional int32 polarity_rephase_increment = 168 [default = 1000];
inline bool SatParameters::has_polarity_rephase_increment() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00040000U);
  return value;
}
inline void SatParameters::clear_polarity_rephase_increment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.polarity_rephase_increment_ = 1000;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00040000U);
}
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::set_polarity_rephase_increment(::int32_t value) {
  _internal_set_polarity_rephase_increment(value);
  SetHasBit(_impl_._has_bits_[6], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.polarity_rephase_increment)
}
inline ::int32_t SatParameters::_internal_polarity_rephase_increment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.polarity_rephase_increment_;
}
inline void SatParameters::_internal_set_polarity_rephase_increment(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.polarity_rephase_increment_ = value;
}
 
// optional bool polarity_exploit_ls_hints = 309 [default = false];
inline bool SatParameters::has_polarity_exploit_ls_hints() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00800000U);
  return value;
}
inline void SatParameters::clear_polarity_exploit_ls_hints() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.polarity_exploit_ls_hints_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00800000U);
}
inline bool SatParameters::polarity_exploit_ls_hints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.polarity_exploit_ls_hints)
  return _internal_polarity_exploit_ls_hints();
}
inline void SatParameters::set_polarity_exploit_ls_hints(bool value) {
  _internal_set_polarity_exploit_ls_hints(value);
  SetHasBit(_impl_._has_bits_[3], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.polarity_exploit_ls_hints)
}
inline bool SatParameters::_internal_polarity_exploit_ls_hints() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.polarity_exploit_ls_hints_;
}
inline void SatParameters::_internal_set_polarity_exploit_ls_hints(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.polarity_exploit_ls_hints_ = value;
}
 
// optional double random_polarity_ratio = 45 [default = 0];
inline bool SatParameters::has_random_polarity_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void SatParameters::clear_random_polarity_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_polarity_ratio_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
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::set_random_polarity_ratio(double value) {
  _internal_set_random_polarity_ratio(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_polarity_ratio)
}
inline double SatParameters::_internal_random_polarity_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.random_polarity_ratio_;
}
inline void SatParameters::_internal_set_random_polarity_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_polarity_ratio_ = value;
}
 
// optional double random_branches_ratio = 32 [default = 0];
inline bool SatParameters::has_random_branches_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x80000000U);
  return value;
}
inline void SatParameters::clear_random_branches_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_branches_ratio_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x80000000U);
}
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::set_random_branches_ratio(double value) {
  _internal_set_random_branches_ratio(value);
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_branches_ratio)
}
inline double SatParameters::_internal_random_branches_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.random_branches_ratio_;
}
inline void SatParameters::_internal_set_random_branches_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_branches_ratio_ = value;
}
 
// optional bool use_erwa_heuristic = 75 [default = false];
inline bool SatParameters::has_use_erwa_heuristic() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000010U);
  return value;
}
inline void SatParameters::clear_use_erwa_heuristic() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_erwa_heuristic_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000010U);
}
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::set_use_erwa_heuristic(bool value) {
  _internal_set_use_erwa_heuristic(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_erwa_heuristic)
}
inline bool SatParameters::_internal_use_erwa_heuristic() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_erwa_heuristic_;
}
inline void SatParameters::_internal_set_use_erwa_heuristic(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_erwa_heuristic_ = value;
}
 
// optional double initial_variables_activity = 76 [default = 0];
inline bool SatParameters::has_initial_variables_activity() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U);
  return value;
}
inline void SatParameters::clear_initial_variables_activity() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initial_variables_activity_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000100U);
}
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::set_initial_variables_activity(double value) {
  _internal_set_initial_variables_activity(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.initial_variables_activity)
}
inline double SatParameters::_internal_initial_variables_activity() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.initial_variables_activity_;
}
inline void SatParameters::_internal_set_initial_variables_activity(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.initial_variables_activity_ = value;
}
 
// optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
inline bool SatParameters::has_also_bump_variables_in_conflict_reasons() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U);
  return value;
}
inline void SatParameters::clear_also_bump_variables_in_conflict_reasons() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.also_bump_variables_in_conflict_reasons_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000200U);
}
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::set_also_bump_variables_in_conflict_reasons(bool value) {
  _internal_set_also_bump_variables_in_conflict_reasons(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.also_bump_variables_in_conflict_reasons)
}
inline bool SatParameters::_internal_also_bump_variables_in_conflict_reasons() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.also_bump_variables_in_conflict_reasons_;
}
inline void SatParameters::_internal_set_also_bump_variables_in_conflict_reasons(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.also_bump_variables_in_conflict_reasons_ = value;
}
 
// optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
inline bool SatParameters::has_minimization_algorithm() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void SatParameters::clear_minimization_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minimization_algorithm_ = 2;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000200U);
}
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::set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
  _internal_set_minimization_algorithm(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimization_algorithm)
}
inline ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm SatParameters::_internal_minimization_algorithm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm>(_impl_.minimization_algorithm_);
}
inline void SatParameters::_internal_set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_internal_data_));
                                          _impl_.minimization_algorithm_ = value;
}
 
// optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS];
inline bool SatParameters::has_binary_minimization_algorithm() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000800U);
  return value;
}
inline void SatParameters::clear_binary_minimization_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.binary_minimization_algorithm_ = 5;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000800U);
}
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::set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
  _internal_set_binary_minimization_algorithm(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.binary_minimization_algorithm)
}
inline ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm SatParameters::_internal_binary_minimization_algorithm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_BinaryMinizationAlgorithm>(_impl_.binary_minimization_algorithm_);
}
inline void SatParameters::_internal_set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_internal_data_));
                                          _impl_.binary_minimization_algorithm_ = value;
}
 
// optional bool subsumption_during_conflict_analysis = 56 [default = true];
inline bool SatParameters::has_subsumption_during_conflict_analysis() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00800000U);
  return value;
}
inline void SatParameters::clear_subsumption_during_conflict_analysis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.subsumption_during_conflict_analysis_ = true;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00800000U);
}
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::set_subsumption_during_conflict_analysis(bool value) {
  _internal_set_subsumption_during_conflict_analysis(value);
  SetHasBit(_impl_._has_bits_[4], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.subsumption_during_conflict_analysis)
}
inline bool SatParameters::_internal_subsumption_during_conflict_analysis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.subsumption_during_conflict_analysis_;
}
inline void SatParameters::_internal_set_subsumption_during_conflict_analysis(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.subsumption_during_conflict_analysis_ = value;
}
 
// optional bool extra_subsumption_during_conflict_analysis = 351 [default = true];
inline bool SatParameters::has_extra_subsumption_during_conflict_analysis() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000400U);
  return value;
}
inline void SatParameters::clear_extra_subsumption_during_conflict_analysis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.extra_subsumption_during_conflict_analysis_ = true;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000400U);
}
inline bool SatParameters::extra_subsumption_during_conflict_analysis() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.extra_subsumption_during_conflict_analysis)
  return _internal_extra_subsumption_during_conflict_analysis();
}
inline void SatParameters::set_extra_subsumption_during_conflict_analysis(bool value) {
  _internal_set_extra_subsumption_during_conflict_analysis(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.extra_subsumption_during_conflict_analysis)
}
inline bool SatParameters::_internal_extra_subsumption_during_conflict_analysis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.extra_subsumption_during_conflict_analysis_;
}
inline void SatParameters::_internal_set_extra_subsumption_during_conflict_analysis(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.extra_subsumption_during_conflict_analysis_ = value;
}
 
// optional bool decision_subsumption_during_conflict_analysis = 353 [default = true];
inline bool SatParameters::has_decision_subsumption_during_conflict_analysis() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00002000U);
  return value;
}
inline void SatParameters::clear_decision_subsumption_during_conflict_analysis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.decision_subsumption_during_conflict_analysis_ = true;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00002000U);
}
inline bool SatParameters::decision_subsumption_during_conflict_analysis() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.decision_subsumption_during_conflict_analysis)
  return _internal_decision_subsumption_during_conflict_analysis();
}
inline void SatParameters::set_decision_subsumption_during_conflict_analysis(bool value) {
  _internal_set_decision_subsumption_during_conflict_analysis(value);
  SetHasBit(_impl_._has_bits_[9], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.decision_subsumption_during_conflict_analysis)
}
inline bool SatParameters::_internal_decision_subsumption_during_conflict_analysis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.decision_subsumption_during_conflict_analysis_;
}
inline void SatParameters::_internal_set_decision_subsumption_during_conflict_analysis(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.decision_subsumption_during_conflict_analysis_ = value;
}
 
// optional int32 eagerly_subsume_last_n_conflicts = 343 [default = 4];
inline bool SatParameters::has_eagerly_subsume_last_n_conflicts() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000800U);
  return value;
}
inline void SatParameters::clear_eagerly_subsume_last_n_conflicts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.eagerly_subsume_last_n_conflicts_ = 4;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000800U);
}
inline ::int32_t SatParameters::eagerly_subsume_last_n_conflicts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.eagerly_subsume_last_n_conflicts)
  return _internal_eagerly_subsume_last_n_conflicts();
}
inline void SatParameters::set_eagerly_subsume_last_n_conflicts(::int32_t value) {
  _internal_set_eagerly_subsume_last_n_conflicts(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.eagerly_subsume_last_n_conflicts)
}
inline ::int32_t SatParameters::_internal_eagerly_subsume_last_n_conflicts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.eagerly_subsume_last_n_conflicts_;
}
inline void SatParameters::_internal_set_eagerly_subsume_last_n_conflicts(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.eagerly_subsume_last_n_conflicts_ = value;
}
 
// optional bool subsume_during_vivification = 355 [default = true];
inline bool SatParameters::has_subsume_during_vivification() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00004000U);
  return value;
}
inline void SatParameters::clear_subsume_during_vivification() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.subsume_during_vivification_ = true;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00004000U);
}
inline bool SatParameters::subsume_during_vivification() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.subsume_during_vivification)
  return _internal_subsume_during_vivification();
}
inline void SatParameters::set_subsume_during_vivification(bool value) {
  _internal_set_subsume_during_vivification(value);
  SetHasBit(_impl_._has_bits_[9], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.subsume_during_vivification)
}
inline bool SatParameters::_internal_subsume_during_vivification() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.subsume_during_vivification_;
}
inline void SatParameters::_internal_set_subsume_during_vivification(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.subsume_during_vivification_ = value;
}
 
// optional bool use_chronological_backtracking = 330 [default = false];
inline bool SatParameters::has_use_chronological_backtracking() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x20000000U);
  return value;
}
inline void SatParameters::clear_use_chronological_backtracking() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_chronological_backtracking_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x20000000U);
}
inline bool SatParameters::use_chronological_backtracking() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_chronological_backtracking)
  return _internal_use_chronological_backtracking();
}
inline void SatParameters::set_use_chronological_backtracking(bool value) {
  _internal_set_use_chronological_backtracking(value);
  SetHasBit(_impl_._has_bits_[3], 0x20000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_chronological_backtracking)
}
inline bool SatParameters::_internal_use_chronological_backtracking() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_chronological_backtracking_;
}
inline void SatParameters::_internal_set_use_chronological_backtracking(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_chronological_backtracking_ = value;
}
 
// optional int32 max_backjump_levels = 331 [default = 50];
inline bool SatParameters::has_max_backjump_levels() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000010U);
  return value;
}
inline void SatParameters::clear_max_backjump_levels() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_backjump_levels_ = 50;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000010U);
}
inline ::int32_t SatParameters::max_backjump_levels() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_backjump_levels)
  return _internal_max_backjump_levels();
}
inline void SatParameters::set_max_backjump_levels(::int32_t value) {
  _internal_set_max_backjump_levels(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_backjump_levels)
}
inline ::int32_t SatParameters::_internal_max_backjump_levels() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_backjump_levels_;
}
inline void SatParameters::_internal_set_max_backjump_levels(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_backjump_levels_ = value;
}
 
// optional int32 chronological_backtrack_min_conflicts = 332 [default = 1000];
inline bool SatParameters::has_chronological_backtrack_min_conflicts() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000020U);
  return value;
}
inline void SatParameters::clear_chronological_backtrack_min_conflicts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chronological_backtrack_min_conflicts_ = 1000;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000020U);
}
inline ::int32_t SatParameters::chronological_backtrack_min_conflicts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.chronological_backtrack_min_conflicts)
  return _internal_chronological_backtrack_min_conflicts();
}
inline void SatParameters::set_chronological_backtrack_min_conflicts(::int32_t value) {
  _internal_set_chronological_backtrack_min_conflicts(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.chronological_backtrack_min_conflicts)
}
inline ::int32_t SatParameters::_internal_chronological_backtrack_min_conflicts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.chronological_backtrack_min_conflicts_;
}
inline void SatParameters::_internal_set_chronological_backtrack_min_conflicts(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.chronological_backtrack_min_conflicts_ = value;
}
 
// optional int32 clause_cleanup_period = 11 [default = 10000];
inline bool SatParameters::has_clause_cleanup_period() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void SatParameters::clear_clause_cleanup_period() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_period_ = 10000;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00002000U);
}
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::set_clause_cleanup_period(::int32_t value) {
  _internal_set_clause_cleanup_period(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_period)
}
inline ::int32_t SatParameters::_internal_clause_cleanup_period() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clause_cleanup_period_;
}
inline void SatParameters::_internal_set_clause_cleanup_period(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_period_ = value;
}
 
// optional int32 clause_cleanup_period_increment = 337 [default = 0];
inline bool SatParameters::has_clause_cleanup_period_increment() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000001U);
  return value;
}
inline void SatParameters::clear_clause_cleanup_period_increment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_period_increment_ = 0;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000001U);
}
inline ::int32_t SatParameters::clause_cleanup_period_increment() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_period_increment)
  return _internal_clause_cleanup_period_increment();
}
inline void SatParameters::set_clause_cleanup_period_increment(::int32_t value) {
  _internal_set_clause_cleanup_period_increment(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_period_increment)
}
inline ::int32_t SatParameters::_internal_clause_cleanup_period_increment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clause_cleanup_period_increment_;
}
inline void SatParameters::_internal_set_clause_cleanup_period_increment(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_period_increment_ = value;
}
 
// optional int32 clause_cleanup_target = 13 [default = 0];
inline bool SatParameters::has_clause_cleanup_target() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void SatParameters::clear_clause_cleanup_target() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_target_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
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::set_clause_cleanup_target(::int32_t value) {
  _internal_set_clause_cleanup_target(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_target)
}
inline ::int32_t SatParameters::_internal_clause_cleanup_target() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clause_cleanup_target_;
}
inline void SatParameters::_internal_set_clause_cleanup_target(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_target_ = value;
}
 
// optional double clause_cleanup_ratio = 190 [default = 0.5];
inline bool SatParameters::has_clause_cleanup_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x01000000U);
  return value;
}
inline void SatParameters::clear_clause_cleanup_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_ratio_ = 0.5;
  ClearHasBit(_impl_._has_bits_[6],
                  0x01000000U);
}
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::set_clause_cleanup_ratio(double value) {
  _internal_set_clause_cleanup_ratio(value);
  SetHasBit(_impl_._has_bits_[6], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_ratio)
}
inline double SatParameters::_internal_clause_cleanup_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clause_cleanup_ratio_;
}
inline void SatParameters::_internal_set_clause_cleanup_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_ratio_ = value;
}
 
// optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
inline bool SatParameters::has_clause_cleanup_lbd_bound() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00080000U);
  return value;
}
inline void SatParameters::clear_clause_cleanup_lbd_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_lbd_bound_ = 5;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00080000U);
}
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::set_clause_cleanup_lbd_bound(::int32_t value) {
  _internal_set_clause_cleanup_lbd_bound(value);
  SetHasBit(_impl_._has_bits_[4], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_lbd_bound)
}
inline ::int32_t SatParameters::_internal_clause_cleanup_lbd_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clause_cleanup_lbd_bound_;
}
inline void SatParameters::_internal_set_clause_cleanup_lbd_bound(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_lbd_bound_ = value;
}
 
// optional int32 clause_cleanup_lbd_tier1 = 349 [default = 0];
inline bool SatParameters::has_clause_cleanup_lbd_tier1() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000020U);
  return value;
}
inline void SatParameters::clear_clause_cleanup_lbd_tier1() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_lbd_tier1_ = 0;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000020U);
}
inline ::int32_t SatParameters::clause_cleanup_lbd_tier1() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_lbd_tier1)
  return _internal_clause_cleanup_lbd_tier1();
}
inline void SatParameters::set_clause_cleanup_lbd_tier1(::int32_t value) {
  _internal_set_clause_cleanup_lbd_tier1(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_lbd_tier1)
}
inline ::int32_t SatParameters::_internal_clause_cleanup_lbd_tier1() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clause_cleanup_lbd_tier1_;
}
inline void SatParameters::_internal_set_clause_cleanup_lbd_tier1(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_lbd_tier1_ = value;
}
 
// optional int32 clause_cleanup_lbd_tier2 = 350 [default = 0];
inline bool SatParameters::has_clause_cleanup_lbd_tier2() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000040U);
  return value;
}
inline void SatParameters::clear_clause_cleanup_lbd_tier2() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_lbd_tier2_ = 0;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000040U);
}
inline ::int32_t SatParameters::clause_cleanup_lbd_tier2() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_lbd_tier2)
  return _internal_clause_cleanup_lbd_tier2();
}
inline void SatParameters::set_clause_cleanup_lbd_tier2(::int32_t value) {
  _internal_set_clause_cleanup_lbd_tier2(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_lbd_tier2)
}
inline ::int32_t SatParameters::_internal_clause_cleanup_lbd_tier2() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clause_cleanup_lbd_tier2_;
}
inline void SatParameters::_internal_set_clause_cleanup_lbd_tier2(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_lbd_tier2_ = value;
}
 
// optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
inline bool SatParameters::has_clause_cleanup_ordering() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000020U);
  return value;
}
inline void SatParameters::clear_clause_cleanup_ordering() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_cleanup_ordering_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000020U);
}
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::set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
  _internal_set_clause_cleanup_ordering(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_ordering)
}
inline ::operations_research::sat::SatParameters_ClauseOrdering SatParameters::_internal_clause_cleanup_ordering() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_ClauseOrdering>(_impl_.clause_cleanup_ordering_);
}
inline void SatParameters::_internal_set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_ClauseOrdering_internal_data_));
                                          _impl_.clause_cleanup_ordering_ = value;
}
 
// optional int32 pb_cleanup_increment = 46 [default = 200];
inline bool SatParameters::has_pb_cleanup_increment() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00001000U);
  return value;
}
inline void SatParameters::clear_pb_cleanup_increment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pb_cleanup_increment_ = 200;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00001000U);
}
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::set_pb_cleanup_increment(::int32_t value) {
  _internal_set_pb_cleanup_increment(value);
  SetHasBit(_impl_._has_bits_[4], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pb_cleanup_increment)
}
inline ::int32_t SatParameters::_internal_pb_cleanup_increment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pb_cleanup_increment_;
}
inline void SatParameters::_internal_set_pb_cleanup_increment(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pb_cleanup_increment_ = value;
}
 
// optional double pb_cleanup_ratio = 47 [default = 0.5];
inline bool SatParameters::has_pb_cleanup_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00002000U);
  return value;
}
inline void SatParameters::clear_pb_cleanup_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pb_cleanup_ratio_ = 0.5;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00002000U);
}
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::set_pb_cleanup_ratio(double value) {
  _internal_set_pb_cleanup_ratio(value);
  SetHasBit(_impl_._has_bits_[4], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pb_cleanup_ratio)
}
inline double SatParameters::_internal_pb_cleanup_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pb_cleanup_ratio_;
}
inline void SatParameters::_internal_set_pb_cleanup_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pb_cleanup_ratio_ = value;
}
 
// optional double variable_activity_decay = 15 [default = 0.8];
inline bool SatParameters::has_variable_activity_decay() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void SatParameters::clear_variable_activity_decay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.variable_activity_decay_ = 0.8;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000400U);
}
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::set_variable_activity_decay(double value) {
  _internal_set_variable_activity_decay(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.variable_activity_decay)
}
inline double SatParameters::_internal_variable_activity_decay() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.variable_activity_decay_;
}
inline void SatParameters::_internal_set_variable_activity_decay(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.variable_activity_decay_ = value;
}
 
// optional double max_variable_activity_value = 16 [default = 1e+100];
inline bool SatParameters::has_max_variable_activity_value() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void SatParameters::clear_max_variable_activity_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_variable_activity_value_ = 1e+100;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000800U);
}
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::set_max_variable_activity_value(double value) {
  _internal_set_max_variable_activity_value(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_variable_activity_value)
}
inline double SatParameters::_internal_max_variable_activity_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_variable_activity_value_;
}
inline void SatParameters::_internal_set_max_variable_activity_value(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_variable_activity_value_ = value;
}
 
// optional double glucose_max_decay = 22 [default = 0.95];
inline bool SatParameters::has_glucose_max_decay() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  return value;
}
inline void SatParameters::clear_glucose_max_decay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.glucose_max_decay_ = 0.95;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00010000U);
}
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::set_glucose_max_decay(double value) {
  _internal_set_glucose_max_decay(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_max_decay)
}
inline double SatParameters::_internal_glucose_max_decay() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.glucose_max_decay_;
}
inline void SatParameters::_internal_set_glucose_max_decay(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.glucose_max_decay_ = value;
}
 
// optional double glucose_decay_increment = 23 [default = 0.01];
inline bool SatParameters::has_glucose_decay_increment() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  return value;
}
inline void SatParameters::clear_glucose_decay_increment() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.glucose_decay_increment_ = 0.01;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00020000U);
}
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::set_glucose_decay_increment(double value) {
  _internal_set_glucose_decay_increment(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_decay_increment)
}
inline double SatParameters::_internal_glucose_decay_increment() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.glucose_decay_increment_;
}
inline void SatParameters::_internal_set_glucose_decay_increment(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.glucose_decay_increment_ = value;
}
 
// optional int32 glucose_decay_increment_period = 24 [default = 5000];
inline bool SatParameters::has_glucose_decay_increment_period() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  return value;
}
inline void SatParameters::clear_glucose_decay_increment_period() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.glucose_decay_increment_period_ = 5000;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00004000U);
}
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::set_glucose_decay_increment_period(::int32_t value) {
  _internal_set_glucose_decay_increment_period(value);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_decay_increment_period)
}
inline ::int32_t SatParameters::_internal_glucose_decay_increment_period() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.glucose_decay_increment_period_;
}
inline void SatParameters::_internal_set_glucose_decay_increment_period(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.glucose_decay_increment_period_ = value;
}
 
// optional double clause_activity_decay = 17 [default = 0.999];
inline bool SatParameters::has_clause_activity_decay() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void SatParameters::clear_clause_activity_decay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_activity_decay_ = 0.999;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00001000U);
}
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::set_clause_activity_decay(double value) {
  _internal_set_clause_activity_decay(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_activity_decay)
}
inline double SatParameters::_internal_clause_activity_decay() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.clause_activity_decay_;
}
inline void SatParameters::_internal_set_clause_activity_decay(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.clause_activity_decay_ = value;
}
 
// optional double max_clause_activity_value = 18 [default = 1e+20];
inline bool SatParameters::has_max_clause_activity_value() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  return value;
}
inline void SatParameters::clear_max_clause_activity_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_clause_activity_value_ = 1e+20;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00008000U);
}
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::set_max_clause_activity_value(double value) {
  _internal_set_max_clause_activity_value(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_clause_activity_value)
}
inline double SatParameters::_internal_max_clause_activity_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_clause_activity_value_;
}
inline void SatParameters::_internal_set_max_clause_activity_value(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_clause_activity_value_ = value;
}
 
// repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
inline int SatParameters::_internal_restart_algorithms_size() const {
  return _internal_restart_algorithms().size();
}
inline int SatParameters::restart_algorithms_size() const {
  return _internal_restart_algorithms_size();
}
inline void SatParameters::clear_restart_algorithms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_algorithms_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00400000U);
}
inline ::operations_research::sat::SatParameters_RestartAlgorithm SatParameters::restart_algorithms(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_algorithms)
  return static_cast<::operations_research::sat::SatParameters_RestartAlgorithm>(_internal_restart_algorithms().Get(index));
}
inline void SatParameters::set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value) {
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_RestartAlgorithm_internal_data_));
                                          _internal_mutable_restart_algorithms()->Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_algorithms)
}
inline void SatParameters::add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value) {
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_RestartAlgorithm_internal_data_));
                                          ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_restart_algorithms()->Add(value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.restart_algorithms)
}
inline const ::google::protobuf::RepeatedField<int>& SatParameters::restart_algorithms() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.restart_algorithms)
  return _internal_restart_algorithms();
}
inline ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL SatParameters::mutable_restart_algorithms()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.restart_algorithms)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_restart_algorithms();
}
inline const ::google::protobuf::RepeatedField<int>& SatParameters::_internal_restart_algorithms()
    const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.restart_algorithms_;
}
inline ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL
SatParameters::_internal_mutable_restart_algorithms() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.restart_algorithms_;
}
 
// optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
inline bool SatParameters::has_default_restart_algorithms() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x10000000U);
  return value;
}
inline void SatParameters::clear_default_restart_algorithms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.default_restart_algorithms_.ClearToDefault(::operations_research::sat::SatParameters::Impl_::_i_give_permission_to_break_this_code_default_default_restart_algorithms_, GetArena());
  ClearHasBit(_impl_._has_bits_[0],
                  0x10000000U);
}
inline const ::std::string& SatParameters::default_restart_algorithms() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.default_restart_algorithms)
  if (_impl_.default_restart_algorithms_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_default_restart_algorithms_.get();
  }
  return _internal_default_restart_algorithms();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SatParameters::set_default_restart_algorithms(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  _impl_.default_restart_algorithms_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.default_restart_algorithms)
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::mutable_default_restart_algorithms()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  ::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 {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.default_restart_algorithms_.Get();
}
inline void SatParameters::_internal_set_default_restart_algorithms(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.default_restart_algorithms_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::_internal_mutable_default_restart_algorithms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.default_restart_algorithms_.Mutable(::operations_research::sat::SatParameters::Impl_::_i_give_permission_to_break_this_code_default_default_restart_algorithms_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SatParameters::release_default_restart_algorithms() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.default_restart_algorithms)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x10000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
  return _impl_.default_restart_algorithms_.Release();
}
inline void SatParameters::set_allocated_default_restart_algorithms(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
  }
  _impl_.default_restart_algorithms_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.default_restart_algorithms)
}
 
// optional int32 restart_period = 30 [default = 50];
inline bool SatParameters::has_restart_period() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
  return value;
}
inline void SatParameters::clear_restart_period() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_period_ = 50;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00040000U);
}
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::set_restart_period(::int32_t value) {
  _internal_set_restart_period(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_period)
}
inline ::int32_t SatParameters::_internal_restart_period() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.restart_period_;
}
inline void SatParameters::_internal_set_restart_period(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_period_ = value;
}
 
// optional int32 restart_running_window_size = 62 [default = 50];
inline bool SatParameters::has_restart_running_window_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00100000U);
  return value;
}
inline void SatParameters::clear_restart_running_window_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_running_window_size_ = 50;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00100000U);
}
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::set_restart_running_window_size(::int32_t value) {
  _internal_set_restart_running_window_size(value);
  SetHasBit(_impl_._has_bits_[4], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_running_window_size)
}
inline ::int32_t SatParameters::_internal_restart_running_window_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.restart_running_window_size_;
}
inline void SatParameters::_internal_set_restart_running_window_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_running_window_size_ = value;
}
 
// optional double restart_dl_average_ratio = 63 [default = 1];
inline bool SatParameters::has_restart_dl_average_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00200000U);
  return value;
}
inline void SatParameters::clear_restart_dl_average_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_dl_average_ratio_ = 1;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00200000U);
}
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::set_restart_dl_average_ratio(double value) {
  _internal_set_restart_dl_average_ratio(value);
  SetHasBit(_impl_._has_bits_[4], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_dl_average_ratio)
}
inline double SatParameters::_internal_restart_dl_average_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.restart_dl_average_ratio_;
}
inline void SatParameters::_internal_set_restart_dl_average_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_dl_average_ratio_ = value;
}
 
// optional double restart_lbd_average_ratio = 71 [default = 1];
inline bool SatParameters::has_restart_lbd_average_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x20000000U);
  return value;
}
inline void SatParameters::clear_restart_lbd_average_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_lbd_average_ratio_ = 1;
  ClearHasBit(_impl_._has_bits_[4],
                  0x20000000U);
}
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::set_restart_lbd_average_ratio(double value) {
  _internal_set_restart_lbd_average_ratio(value);
  SetHasBit(_impl_._has_bits_[4], 0x20000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_lbd_average_ratio)
}
inline double SatParameters::_internal_restart_lbd_average_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.restart_lbd_average_ratio_;
}
inline void SatParameters::_internal_set_restart_lbd_average_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.restart_lbd_average_ratio_ = value;
}
 
// optional bool use_blocking_restart = 64 [default = false];
inline bool SatParameters::has_use_blocking_restart() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000008U);
  return value;
}
inline void SatParameters::clear_use_blocking_restart() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_blocking_restart_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000008U);
}
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::set_use_blocking_restart(bool value) {
  _internal_set_use_blocking_restart(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_blocking_restart)
}
inline bool SatParameters::_internal_use_blocking_restart() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_blocking_restart_;
}
inline void SatParameters::_internal_set_use_blocking_restart(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_blocking_restart_ = value;
}
 
// optional int32 blocking_restart_window_size = 65 [default = 5000];
inline bool SatParameters::has_blocking_restart_window_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x04000000U);
  return value;
}
inline void SatParameters::clear_blocking_restart_window_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.blocking_restart_window_size_ = 5000;
  ClearHasBit(_impl_._has_bits_[4],
                  0x04000000U);
}
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::set_blocking_restart_window_size(::int32_t value) {
  _internal_set_blocking_restart_window_size(value);
  SetHasBit(_impl_._has_bits_[4], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.blocking_restart_window_size)
}
inline ::int32_t SatParameters::_internal_blocking_restart_window_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.blocking_restart_window_size_;
}
inline void SatParameters::_internal_set_blocking_restart_window_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.blocking_restart_window_size_ = value;
}
 
// optional double blocking_restart_multiplier = 66 [default = 1.4];
inline bool SatParameters::has_blocking_restart_multiplier() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x08000000U);
  return value;
}
inline void SatParameters::clear_blocking_restart_multiplier() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.blocking_restart_multiplier_ = 1.4;
  ClearHasBit(_impl_._has_bits_[4],
                  0x08000000U);
}
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::set_blocking_restart_multiplier(double value) {
  _internal_set_blocking_restart_multiplier(value);
  SetHasBit(_impl_._has_bits_[4], 0x08000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.blocking_restart_multiplier)
}
inline double SatParameters::_internal_blocking_restart_multiplier() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.blocking_restart_multiplier_;
}
inline void SatParameters::_internal_set_blocking_restart_multiplier(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.blocking_restart_multiplier_ = value;
}
 
// optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
inline bool SatParameters::has_num_conflicts_before_strategy_changes() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U);
  return value;
}
inline void SatParameters::clear_num_conflicts_before_strategy_changes() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_conflicts_before_strategy_changes_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000040U);
}
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::set_num_conflicts_before_strategy_changes(::int32_t value) {
  _internal_set_num_conflicts_before_strategy_changes(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_conflicts_before_strategy_changes)
}
inline ::int32_t SatParameters::_internal_num_conflicts_before_strategy_changes() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_conflicts_before_strategy_changes_;
}
inline void SatParameters::_internal_set_num_conflicts_before_strategy_changes(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_conflicts_before_strategy_changes_ = value;
}
 
// optional double strategy_change_increase_ratio = 69 [default = 0];
inline bool SatParameters::has_strategy_change_increase_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U);
  return value;
}
inline void SatParameters::clear_strategy_change_increase_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.strategy_change_increase_ratio_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000080U);
}
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::set_strategy_change_increase_ratio(double value) {
  _internal_set_strategy_change_increase_ratio(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.strategy_change_increase_ratio)
}
inline double SatParameters::_internal_strategy_change_increase_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.strategy_change_increase_ratio_;
}
inline void SatParameters::_internal_set_strategy_change_increase_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.strategy_change_increase_ratio_ = value;
}
 
// optional double max_time_in_seconds = 36 [default = inf];
inline bool SatParameters::has_max_time_in_seconds() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00100000U);
  return value;
}
inline void SatParameters::clear_max_time_in_seconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_time_in_seconds_ = std::numeric_limits<double>::infinity();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00100000U);
}
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::set_max_time_in_seconds(double value) {
  _internal_set_max_time_in_seconds(value);
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_time_in_seconds)
}
inline double SatParameters::_internal_max_time_in_seconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_time_in_seconds_;
}
inline void SatParameters::_internal_set_max_time_in_seconds(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_time_in_seconds_ = value;
}
 
// optional double max_deterministic_time = 67 [default = inf];
inline bool SatParameters::has_max_deterministic_time() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x10000000U);
  return value;
}
inline void SatParameters::clear_max_deterministic_time() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_deterministic_time_ = std::numeric_limits<double>::infinity();
  ClearHasBit(_impl_._has_bits_[4],
                  0x10000000U);
}
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::set_max_deterministic_time(double value) {
  _internal_set_max_deterministic_time(value);
  SetHasBit(_impl_._has_bits_[4], 0x10000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_deterministic_time)
}
inline double SatParameters::_internal_max_deterministic_time() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_deterministic_time_;
}
inline void SatParameters::_internal_set_max_deterministic_time(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_deterministic_time_ = value;
}
 
// optional int32 max_num_deterministic_batches = 291 [default = 0];
inline bool SatParameters::has_max_num_deterministic_batches() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00008000U);
  return value;
}
inline void SatParameters::clear_max_num_deterministic_batches() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_num_deterministic_batches_ = 0;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00008000U);
}
inline ::int32_t SatParameters::max_num_deterministic_batches() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_num_deterministic_batches)
  return _internal_max_num_deterministic_batches();
}
inline void SatParameters::set_max_num_deterministic_batches(::int32_t value) {
  _internal_set_max_num_deterministic_batches(value);
  SetHasBit(_impl_._has_bits_[3], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_num_deterministic_batches)
}
inline ::int32_t SatParameters::_internal_max_num_deterministic_batches() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_num_deterministic_batches_;
}
inline void SatParameters::_internal_set_max_num_deterministic_batches(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_num_deterministic_batches_ = value;
}
 
// optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
inline bool SatParameters::has_max_number_of_conflicts() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00200000U);
  return value;
}
inline void SatParameters::clear_max_number_of_conflicts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_number_of_conflicts_ = ::int64_t{9223372036854775807};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00200000U);
}
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::set_max_number_of_conflicts(::int64_t value) {
  _internal_set_max_number_of_conflicts(value);
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_number_of_conflicts)
}
inline ::int64_t SatParameters::_internal_max_number_of_conflicts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_number_of_conflicts_;
}
inline void SatParameters::_internal_set_max_number_of_conflicts(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_number_of_conflicts_ = value;
}
 
// optional int64 max_memory_in_mb = 40 [default = 10000];
inline bool SatParameters::has_max_memory_in_mb() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000400U);
  return value;
}
inline void SatParameters::clear_max_memory_in_mb() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_memory_in_mb_ = ::int64_t{10000};
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000400U);
}
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::set_max_memory_in_mb(::int64_t value) {
  _internal_set_max_memory_in_mb(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_memory_in_mb)
}
inline ::int64_t SatParameters::_internal_max_memory_in_mb() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_memory_in_mb_;
}
inline void SatParameters::_internal_set_max_memory_in_mb(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_memory_in_mb_ = value;
}
 
// optional double absolute_gap_limit = 159 [default = 0.0001];
inline bool SatParameters::has_absolute_gap_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000800U);
  return value;
}
inline void SatParameters::clear_absolute_gap_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.absolute_gap_limit_ = 0.0001;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000800U);
}
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::set_absolute_gap_limit(double value) {
  _internal_set_absolute_gap_limit(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.absolute_gap_limit)
}
inline double SatParameters::_internal_absolute_gap_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.absolute_gap_limit_;
}
inline void SatParameters::_internal_set_absolute_gap_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.absolute_gap_limit_ = value;
}
 
// optional double relative_gap_limit = 160 [default = 0];
inline bool SatParameters::has_relative_gap_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x40000000U);
  return value;
}
inline void SatParameters::clear_relative_gap_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.relative_gap_limit_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x40000000U);
}
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::set_relative_gap_limit(double value) {
  _internal_set_relative_gap_limit(value);
  SetHasBit(_impl_._has_bits_[1], 0x40000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.relative_gap_limit)
}
inline double SatParameters::_internal_relative_gap_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.relative_gap_limit_;
}
inline void SatParameters::_internal_set_relative_gap_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.relative_gap_limit_ = value;
}
 
// optional int32 random_seed = 31 [default = 1];
inline bool SatParameters::has_random_seed() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00080000U);
  return value;
}
inline void SatParameters::clear_random_seed() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_seed_ = 1;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00080000U);
}
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::set_random_seed(::int32_t value) {
  _internal_set_random_seed(value);
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_seed)
}
inline ::int32_t SatParameters::_internal_random_seed() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.random_seed_;
}
inline void SatParameters::_internal_set_random_seed(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_seed_ = value;
}
 
// optional bool permute_variable_randomly = 178 [default = false];
inline bool SatParameters::has_permute_variable_randomly() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000100U);
  return value;
}
inline void SatParameters::clear_permute_variable_randomly() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.permute_variable_randomly_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000100U);
}
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::set_permute_variable_randomly(bool value) {
  _internal_set_permute_variable_randomly(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.permute_variable_randomly)
}
inline bool SatParameters::_internal_permute_variable_randomly() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.permute_variable_randomly_;
}
inline void SatParameters::_internal_set_permute_variable_randomly(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.permute_variable_randomly_ = value;
}
 
// optional bool permute_presolve_constraint_order = 179 [default = false];
inline bool SatParameters::has_permute_presolve_constraint_order() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000200U);
  return value;
}
inline void SatParameters::clear_permute_presolve_constraint_order() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.permute_presolve_constraint_order_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000200U);
}
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::set_permute_presolve_constraint_order(bool value) {
  _internal_set_permute_presolve_constraint_order(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.permute_presolve_constraint_order)
}
inline bool SatParameters::_internal_permute_presolve_constraint_order() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.permute_presolve_constraint_order_;
}
inline void SatParameters::_internal_set_permute_presolve_constraint_order(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.permute_presolve_constraint_order_ = value;
}
 
// optional bool use_absl_random = 180 [default = false];
inline bool SatParameters::has_use_absl_random() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000400U);
  return value;
}
inline void SatParameters::clear_use_absl_random() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_absl_random_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000400U);
}
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::set_use_absl_random(bool value) {
  _internal_set_use_absl_random(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_absl_random)
}
inline bool SatParameters::_internal_use_absl_random() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_absl_random_;
}
inline void SatParameters::_internal_set_use_absl_random(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_absl_random_ = value;
}
 
// optional bool log_search_progress = 41 [default = false];
inline bool SatParameters::has_log_search_progress() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void SatParameters::clear_log_search_progress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_search_progress_ = false;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
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::set_log_search_progress(bool value) {
  _internal_set_log_search_progress(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_search_progress)
}
inline bool SatParameters::_internal_log_search_progress() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_search_progress_;
}
inline void SatParameters::_internal_set_log_search_progress(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_search_progress_ = value;
}
 
// optional bool log_subsolver_statistics = 189 [default = false];
inline bool SatParameters::has_log_subsolver_statistics() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00004000U);
  return value;
}
inline void SatParameters::clear_log_subsolver_statistics() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_subsolver_statistics_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00004000U);
}
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::set_log_subsolver_statistics(bool value) {
  _internal_set_log_subsolver_statistics(value);
  SetHasBit(_impl_._has_bits_[2], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_subsolver_statistics)
}
inline bool SatParameters::_internal_log_subsolver_statistics() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_subsolver_statistics_;
}
inline void SatParameters::_internal_set_log_subsolver_statistics(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_subsolver_statistics_ = value;
}
 
// optional string log_prefix = 185 [default = ""];
inline bool SatParameters::has_log_prefix() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x40000000U);
  return value;
}
inline void SatParameters::clear_log_prefix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_prefix_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x40000000U);
}
inline const ::std::string& SatParameters::log_prefix() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_prefix)
  return _internal_log_prefix();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SatParameters::set_log_prefix(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  _impl_.log_prefix_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_prefix)
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::mutable_log_prefix()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  ::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 {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_prefix_.Get();
}
inline void SatParameters::_internal_set_log_prefix(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_prefix_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::_internal_mutable_log_prefix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.log_prefix_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SatParameters::release_log_prefix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.log_prefix)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x40000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  auto* released = _impl_.log_prefix_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.log_prefix_.Set("", GetArena());
  }
  return released;
}
inline void SatParameters::set_allocated_log_prefix(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  }
  _impl_.log_prefix_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.log_prefix_.IsDefault()) {
    _impl_.log_prefix_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.log_prefix)
}
 
// optional bool log_to_stdout = 186 [default = true];
inline bool SatParameters::has_log_to_stdout() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00400000U);
  return value;
}
inline void SatParameters::clear_log_to_stdout() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_to_stdout_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00400000U);
}
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::set_log_to_stdout(bool value) {
  _internal_set_log_to_stdout(value);
  SetHasBit(_impl_._has_bits_[6], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_to_stdout)
}
inline bool SatParameters::_internal_log_to_stdout() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_to_stdout_;
}
inline void SatParameters::_internal_set_log_to_stdout(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_to_stdout_ = value;
}
 
// optional bool log_to_response = 187 [default = false];
inline bool SatParameters::has_log_to_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00001000U);
  return value;
}
inline void SatParameters::clear_log_to_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_to_response_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00001000U);
}
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::set_log_to_response(bool value) {
  _internal_set_log_to_response(value);
  SetHasBit(_impl_._has_bits_[2], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_to_response)
}
inline bool SatParameters::_internal_log_to_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.log_to_response_;
}
inline void SatParameters::_internal_set_log_to_response(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.log_to_response_ = value;
}
 
// optional bool use_pb_resolution = 43 [default = false];
inline bool SatParameters::has_use_pb_resolution() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void SatParameters::clear_use_pb_resolution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_pb_resolution_ = false;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000010U);
}
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::set_use_pb_resolution(bool value) {
  _internal_set_use_pb_resolution(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_pb_resolution)
}
inline bool SatParameters::_internal_use_pb_resolution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_pb_resolution_;
}
inline void SatParameters::_internal_set_use_pb_resolution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_pb_resolution_ = value;
}
 
// optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
inline bool SatParameters::has_minimize_reduction_during_pb_resolution() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000002U);
  return value;
}
inline void SatParameters::clear_minimize_reduction_during_pb_resolution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minimize_reduction_during_pb_resolution_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000002U);
}
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::set_minimize_reduction_during_pb_resolution(bool value) {
  _internal_set_minimize_reduction_during_pb_resolution(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_reduction_during_pb_resolution)
}
inline bool SatParameters::_internal_minimize_reduction_during_pb_resolution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.minimize_reduction_during_pb_resolution_;
}
inline void SatParameters::_internal_set_minimize_reduction_during_pb_resolution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minimize_reduction_during_pb_resolution_ = value;
}
 
// optional bool count_assumption_levels_in_lbd = 49 [default = true];
inline bool SatParameters::has_count_assumption_levels_in_lbd() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00400000U);
  return value;
}
inline void SatParameters::clear_count_assumption_levels_in_lbd() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.count_assumption_levels_in_lbd_ = true;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00400000U);
}
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::set_count_assumption_levels_in_lbd(bool value) {
  _internal_set_count_assumption_levels_in_lbd(value);
  SetHasBit(_impl_._has_bits_[4], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.count_assumption_levels_in_lbd)
}
inline bool SatParameters::_internal_count_assumption_levels_in_lbd() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.count_assumption_levels_in_lbd_;
}
inline void SatParameters::_internal_set_count_assumption_levels_in_lbd(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.count_assumption_levels_in_lbd_ = value;
}
 
// optional int32 presolve_bve_threshold = 54 [default = 500];
inline bool SatParameters::has_presolve_bve_threshold() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00010000U);
  return value;
}
inline void SatParameters::clear_presolve_bve_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_bve_threshold_ = 500;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00010000U);
}
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::set_presolve_bve_threshold(::int32_t value) {
  _internal_set_presolve_bve_threshold(value);
  SetHasBit(_impl_._has_bits_[4], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bve_threshold)
}
inline ::int32_t SatParameters::_internal_presolve_bve_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_bve_threshold_;
}
inline void SatParameters::_internal_set_presolve_bve_threshold(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_bve_threshold_ = value;
}
 
// optional bool filter_sat_postsolve_clauses = 324 [default = false];
inline bool SatParameters::has_filter_sat_postsolve_clauses() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x02000000U);
  return value;
}
inline void SatParameters::clear_filter_sat_postsolve_clauses() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filter_sat_postsolve_clauses_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x02000000U);
}
inline bool SatParameters::filter_sat_postsolve_clauses() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.filter_sat_postsolve_clauses)
  return _internal_filter_sat_postsolve_clauses();
}
inline void SatParameters::set_filter_sat_postsolve_clauses(bool value) {
  _internal_set_filter_sat_postsolve_clauses(value);
  SetHasBit(_impl_._has_bits_[3], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.filter_sat_postsolve_clauses)
}
inline bool SatParameters::_internal_filter_sat_postsolve_clauses() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filter_sat_postsolve_clauses_;
}
inline void SatParameters::_internal_set_filter_sat_postsolve_clauses(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filter_sat_postsolve_clauses_ = value;
}
 
// optional int32 presolve_bve_clause_weight = 55 [default = 3];
inline bool SatParameters::has_presolve_bve_clause_weight() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00020000U);
  return value;
}
inline void SatParameters::clear_presolve_bve_clause_weight() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_bve_clause_weight_ = 3;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00020000U);
}
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::set_presolve_bve_clause_weight(::int32_t value) {
  _internal_set_presolve_bve_clause_weight(value);
  SetHasBit(_impl_._has_bits_[4], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bve_clause_weight)
}
inline ::int32_t SatParameters::_internal_presolve_bve_clause_weight() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_bve_clause_weight_;
}
inline void SatParameters::_internal_set_presolve_bve_clause_weight(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_bve_clause_weight_ = value;
}
 
// optional double probing_deterministic_time_limit = 226 [default = 1];
inline bool SatParameters::has_probing_deterministic_time_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000080U);
  return value;
}
inline void SatParameters::clear_probing_deterministic_time_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.probing_deterministic_time_limit_ = 1;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000080U);
}
inline double SatParameters::probing_deterministic_time_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.probing_deterministic_time_limit)
  return _internal_probing_deterministic_time_limit();
}
inline void SatParameters::set_probing_deterministic_time_limit(double value) {
  _internal_set_probing_deterministic_time_limit(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.probing_deterministic_time_limit)
}
inline double SatParameters::_internal_probing_deterministic_time_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.probing_deterministic_time_limit_;
}
inline void SatParameters::_internal_set_probing_deterministic_time_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.probing_deterministic_time_limit_ = value;
}
 
// optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
inline bool SatParameters::has_presolve_probing_deterministic_time_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00040000U);
  return value;
}
inline void SatParameters::clear_presolve_probing_deterministic_time_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_probing_deterministic_time_limit_ = 30;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00040000U);
}
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::set_presolve_probing_deterministic_time_limit(double value) {
  _internal_set_presolve_probing_deterministic_time_limit(value);
  SetHasBit(_impl_._has_bits_[4], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_probing_deterministic_time_limit)
}
inline double SatParameters::_internal_presolve_probing_deterministic_time_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_probing_deterministic_time_limit_;
}
inline void SatParameters::_internal_set_presolve_probing_deterministic_time_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_probing_deterministic_time_limit_ = value;
}
 
// optional bool presolve_blocked_clause = 88 [default = true];
inline bool SatParameters::has_presolve_blocked_clause() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000002U);
  return value;
}
inline void SatParameters::clear_presolve_blocked_clause() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_blocked_clause_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000002U);
}
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::set_presolve_blocked_clause(bool value) {
  _internal_set_presolve_blocked_clause(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_blocked_clause)
}
inline bool SatParameters::_internal_presolve_blocked_clause() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_blocked_clause_;
}
inline void SatParameters::_internal_set_presolve_blocked_clause(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_blocked_clause_ = value;
}
 
// optional bool presolve_use_bva = 72 [default = true];
inline bool SatParameters::has_presolve_use_bva() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x01000000U);
  return value;
}
inline void SatParameters::clear_presolve_use_bva() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_use_bva_ = true;
  ClearHasBit(_impl_._has_bits_[4],
                  0x01000000U);
}
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::set_presolve_use_bva(bool value) {
  _internal_set_presolve_use_bva(value);
  SetHasBit(_impl_._has_bits_[4], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_use_bva)
}
inline bool SatParameters::_internal_presolve_use_bva() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_use_bva_;
}
inline void SatParameters::_internal_set_presolve_use_bva(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_use_bva_ = value;
}
 
// optional int32 presolve_bva_threshold = 73 [default = 1];
inline bool SatParameters::has_presolve_bva_threshold() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x40000000U);
  return value;
}
inline void SatParameters::clear_presolve_bva_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_bva_threshold_ = 1;
  ClearHasBit(_impl_._has_bits_[4],
                  0x40000000U);
}
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::set_presolve_bva_threshold(::int32_t value) {
  _internal_set_presolve_bva_threshold(value);
  SetHasBit(_impl_._has_bits_[4], 0x40000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bva_threshold)
}
inline ::int32_t SatParameters::_internal_presolve_bva_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_bva_threshold_;
}
inline void SatParameters::_internal_set_presolve_bva_threshold(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_bva_threshold_ = value;
}
 
// optional int32 max_presolve_iterations = 138 [default = 3];
inline bool SatParameters::has_max_presolve_iterations() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x40000000U);
  return value;
}
inline void SatParameters::clear_max_presolve_iterations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_presolve_iterations_ = 3;
  ClearHasBit(_impl_._has_bits_[5],
                  0x40000000U);
}
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::set_max_presolve_iterations(::int32_t value) {
  _internal_set_max_presolve_iterations(value);
  SetHasBit(_impl_._has_bits_[5], 0x40000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_presolve_iterations)
}
inline ::int32_t SatParameters::_internal_max_presolve_iterations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_presolve_iterations_;
}
inline void SatParameters::_internal_set_max_presolve_iterations(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_presolve_iterations_ = value;
}
 
// optional bool cp_model_presolve = 86 [default = true];
inline bool SatParameters::has_cp_model_presolve() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000001U);
  return value;
}
inline void SatParameters::clear_cp_model_presolve() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cp_model_presolve_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000001U);
}
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::set_cp_model_presolve(bool value) {
  _internal_set_cp_model_presolve(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_presolve)
}
inline bool SatParameters::_internal_cp_model_presolve() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cp_model_presolve_;
}
inline void SatParameters::_internal_set_cp_model_presolve(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cp_model_presolve_ = value;
}
 
// optional int32 cp_model_probing_level = 110 [default = 2];
inline bool SatParameters::has_cp_model_probing_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000800U);
  return value;
}
inline void SatParameters::clear_cp_model_probing_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cp_model_probing_level_ = 2;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000800U);
}
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::set_cp_model_probing_level(::int32_t value) {
  _internal_set_cp_model_probing_level(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_probing_level)
}
inline ::int32_t SatParameters::_internal_cp_model_probing_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cp_model_probing_level_;
}
inline void SatParameters::_internal_set_cp_model_probing_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cp_model_probing_level_ = value;
}
 
// optional bool cp_model_use_sat_presolve = 93 [default = true];
inline bool SatParameters::has_cp_model_use_sat_presolve() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000020U);
  return value;
}
inline void SatParameters::clear_cp_model_use_sat_presolve() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cp_model_use_sat_presolve_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000020U);
}
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::set_cp_model_use_sat_presolve(bool value) {
  _internal_set_cp_model_use_sat_presolve(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
}
inline bool SatParameters::_internal_cp_model_use_sat_presolve() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cp_model_use_sat_presolve_;
}
inline void SatParameters::_internal_set_cp_model_use_sat_presolve(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cp_model_use_sat_presolve_ = value;
}
 
// optional bool load_at_most_ones_in_sat_presolve = 335 [default = false];
inline bool SatParameters::has_load_at_most_ones_in_sat_presolve() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x40000000U);
  return value;
}
inline void SatParameters::clear_load_at_most_ones_in_sat_presolve() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.load_at_most_ones_in_sat_presolve_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x40000000U);
}
inline bool SatParameters::load_at_most_ones_in_sat_presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.load_at_most_ones_in_sat_presolve)
  return _internal_load_at_most_ones_in_sat_presolve();
}
inline void SatParameters::set_load_at_most_ones_in_sat_presolve(bool value) {
  _internal_set_load_at_most_ones_in_sat_presolve(value);
  SetHasBit(_impl_._has_bits_[3], 0x40000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.load_at_most_ones_in_sat_presolve)
}
inline bool SatParameters::_internal_load_at_most_ones_in_sat_presolve() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.load_at_most_ones_in_sat_presolve_;
}
inline void SatParameters::_internal_set_load_at_most_ones_in_sat_presolve(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.load_at_most_ones_in_sat_presolve_ = value;
}
 
// optional bool remove_fixed_variables_early = 310 [default = true];
inline bool SatParameters::has_remove_fixed_variables_early() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00800000U);
  return value;
}
inline void SatParameters::clear_remove_fixed_variables_early() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.remove_fixed_variables_early_ = true;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00800000U);
}
inline bool SatParameters::remove_fixed_variables_early() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.remove_fixed_variables_early)
  return _internal_remove_fixed_variables_early();
}
inline void SatParameters::set_remove_fixed_variables_early(bool value) {
  _internal_set_remove_fixed_variables_early(value);
  SetHasBit(_impl_._has_bits_[8], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.remove_fixed_variables_early)
}
inline bool SatParameters::_internal_remove_fixed_variables_early() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.remove_fixed_variables_early_;
}
inline void SatParameters::_internal_set_remove_fixed_variables_early(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.remove_fixed_variables_early_ = value;
}
 
// optional bool detect_table_with_cost = 216 [default = false];
inline bool SatParameters::has_detect_table_with_cost() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00800000U);
  return value;
}
inline void SatParameters::clear_detect_table_with_cost() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.detect_table_with_cost_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00800000U);
}
inline bool SatParameters::detect_table_with_cost() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.detect_table_with_cost)
  return _internal_detect_table_with_cost();
}
inline void SatParameters::set_detect_table_with_cost(bool value) {
  _internal_set_detect_table_with_cost(value);
  SetHasBit(_impl_._has_bits_[2], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.detect_table_with_cost)
}
inline bool SatParameters::_internal_detect_table_with_cost() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.detect_table_with_cost_;
}
inline void SatParameters::_internal_set_detect_table_with_cost(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.detect_table_with_cost_ = value;
}
 
// optional int32 table_compression_level = 217 [default = 2];
inline bool SatParameters::has_table_compression_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000020U);
  return value;
}
inline void SatParameters::clear_table_compression_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.table_compression_level_ = 2;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000020U);
}
inline ::int32_t SatParameters::table_compression_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.table_compression_level)
  return _internal_table_compression_level();
}
inline void SatParameters::set_table_compression_level(::int32_t value) {
  _internal_set_table_compression_level(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.table_compression_level)
}
inline ::int32_t SatParameters::_internal_table_compression_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.table_compression_level_;
}
inline void SatParameters::_internal_set_table_compression_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.table_compression_level_ = value;
}
 
// optional bool expand_alldiff_constraints = 170 [default = false];
inline bool SatParameters::has_expand_alldiff_constraints() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000008U);
  return value;
}
inline void SatParameters::clear_expand_alldiff_constraints() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.expand_alldiff_constraints_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000008U);
}
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::set_expand_alldiff_constraints(bool value) {
  _internal_set_expand_alldiff_constraints(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_alldiff_constraints)
}
inline bool SatParameters::_internal_expand_alldiff_constraints() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.expand_alldiff_constraints_;
}
inline void SatParameters::_internal_set_expand_alldiff_constraints(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.expand_alldiff_constraints_ = value;
}
 
// optional int32 max_alldiff_domain_size = 320 [default = 256];
inline bool SatParameters::has_max_alldiff_domain_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x20000000U);
  return value;
}
inline void SatParameters::clear_max_alldiff_domain_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_alldiff_domain_size_ = 256;
  ClearHasBit(_impl_._has_bits_[8],
                  0x20000000U);
}
inline ::int32_t SatParameters::max_alldiff_domain_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_alldiff_domain_size)
  return _internal_max_alldiff_domain_size();
}
inline void SatParameters::set_max_alldiff_domain_size(::int32_t value) {
  _internal_set_max_alldiff_domain_size(value);
  SetHasBit(_impl_._has_bits_[8], 0x20000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_alldiff_domain_size)
}
inline ::int32_t SatParameters::_internal_max_alldiff_domain_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_alldiff_domain_size_;
}
inline void SatParameters::_internal_set_max_alldiff_domain_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_alldiff_domain_size_ = value;
}
 
// optional bool expand_reservoir_constraints = 182 [default = true];
inline bool SatParameters::has_expand_reservoir_constraints() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00200000U);
  return value;
}
inline void SatParameters::clear_expand_reservoir_constraints() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.expand_reservoir_constraints_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00200000U);
}
inline bool SatParameters::expand_reservoir_constraints() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_reservoir_constraints)
  return _internal_expand_reservoir_constraints();
}
inline void SatParameters::set_expand_reservoir_constraints(bool value) {
  _internal_set_expand_reservoir_constraints(value);
  SetHasBit(_impl_._has_bits_[6], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_reservoir_constraints)
}
inline bool SatParameters::_internal_expand_reservoir_constraints() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.expand_reservoir_constraints_;
}
inline void SatParameters::_internal_set_expand_reservoir_constraints(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.expand_reservoir_constraints_ = value;
}
 
// optional int32 max_domain_size_for_linear2_expansion = 340 [default = 8];
inline bool SatParameters::has_max_domain_size_for_linear2_expansion() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000040U);
  return value;
}
inline void SatParameters::clear_max_domain_size_for_linear2_expansion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_domain_size_for_linear2_expansion_ = 8;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000040U);
}
inline ::int32_t SatParameters::max_domain_size_for_linear2_expansion() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_domain_size_for_linear2_expansion)
  return _internal_max_domain_size_for_linear2_expansion();
}
inline void SatParameters::set_max_domain_size_for_linear2_expansion(::int32_t value) {
  _internal_set_max_domain_size_for_linear2_expansion(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_domain_size_for_linear2_expansion)
}
inline ::int32_t SatParameters::_internal_max_domain_size_for_linear2_expansion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_domain_size_for_linear2_expansion_;
}
inline void SatParameters::_internal_set_max_domain_size_for_linear2_expansion(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_domain_size_for_linear2_expansion_ = value;
}
 
// optional bool expand_reservoir_using_circuit = 288 [default = false];
inline bool SatParameters::has_expand_reservoir_using_circuit() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00004000U);
  return value;
}
inline void SatParameters::clear_expand_reservoir_using_circuit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.expand_reservoir_using_circuit_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00004000U);
}
inline bool SatParameters::expand_reservoir_using_circuit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_reservoir_using_circuit)
  return _internal_expand_reservoir_using_circuit();
}
inline void SatParameters::set_expand_reservoir_using_circuit(bool value) {
  _internal_set_expand_reservoir_using_circuit(value);
  SetHasBit(_impl_._has_bits_[3], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_reservoir_using_circuit)
}
inline bool SatParameters::_internal_expand_reservoir_using_circuit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.expand_reservoir_using_circuit_;
}
inline void SatParameters::_internal_set_expand_reservoir_using_circuit(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.expand_reservoir_using_circuit_ = value;
}
 
// optional bool encode_cumulative_as_reservoir = 287 [default = false];
inline bool SatParameters::has_encode_cumulative_as_reservoir() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00002000U);
  return value;
}
inline void SatParameters::clear_encode_cumulative_as_reservoir() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.encode_cumulative_as_reservoir_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00002000U);
}
inline bool SatParameters::encode_cumulative_as_reservoir() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.encode_cumulative_as_reservoir)
  return _internal_encode_cumulative_as_reservoir();
}
inline void SatParameters::set_encode_cumulative_as_reservoir(bool value) {
  _internal_set_encode_cumulative_as_reservoir(value);
  SetHasBit(_impl_._has_bits_[3], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.encode_cumulative_as_reservoir)
}
inline bool SatParameters::_internal_encode_cumulative_as_reservoir() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.encode_cumulative_as_reservoir_;
}
inline void SatParameters::_internal_set_encode_cumulative_as_reservoir(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.encode_cumulative_as_reservoir_ = value;
}
 
// optional int32 max_lin_max_size_for_expansion = 280 [default = 0];
inline bool SatParameters::has_max_lin_max_size_for_expansion() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000400U);
  return value;
}
inline void SatParameters::clear_max_lin_max_size_for_expansion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_lin_max_size_for_expansion_ = 0;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000400U);
}
inline ::int32_t SatParameters::max_lin_max_size_for_expansion() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_lin_max_size_for_expansion)
  return _internal_max_lin_max_size_for_expansion();
}
inline void SatParameters::set_max_lin_max_size_for_expansion(::int32_t value) {
  _internal_set_max_lin_max_size_for_expansion(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_lin_max_size_for_expansion)
}
inline ::int32_t SatParameters::_internal_max_lin_max_size_for_expansion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_lin_max_size_for_expansion_;
}
inline void SatParameters::_internal_set_max_lin_max_size_for_expansion(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_lin_max_size_for_expansion_ = value;
}
 
// optional bool disable_constraint_expansion = 181 [default = false];
inline bool SatParameters::has_disable_constraint_expansion() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000800U);
  return value;
}
inline void SatParameters::clear_disable_constraint_expansion() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.disable_constraint_expansion_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000800U);
}
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::set_disable_constraint_expansion(bool value) {
  _internal_set_disable_constraint_expansion(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.disable_constraint_expansion)
}
inline bool SatParameters::_internal_disable_constraint_expansion() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.disable_constraint_expansion_;
}
inline void SatParameters::_internal_set_disable_constraint_expansion(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.disable_constraint_expansion_ = value;
}
 
// optional bool encode_complex_linear_constraint_with_integer = 223 [default = false];
inline bool SatParameters::has_encode_complex_linear_constraint_with_integer() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x04000000U);
  return value;
}
inline void SatParameters::clear_encode_complex_linear_constraint_with_integer() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.encode_complex_linear_constraint_with_integer_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x04000000U);
}
inline bool SatParameters::encode_complex_linear_constraint_with_integer() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.encode_complex_linear_constraint_with_integer)
  return _internal_encode_complex_linear_constraint_with_integer();
}
inline void SatParameters::set_encode_complex_linear_constraint_with_integer(bool value) {
  _internal_set_encode_complex_linear_constraint_with_integer(value);
  SetHasBit(_impl_._has_bits_[2], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.encode_complex_linear_constraint_with_integer)
}
inline bool SatParameters::_internal_encode_complex_linear_constraint_with_integer() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.encode_complex_linear_constraint_with_integer_;
}
inline void SatParameters::_internal_set_encode_complex_linear_constraint_with_integer(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.encode_complex_linear_constraint_with_integer_ = value;
}
 
// optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
inline bool SatParameters::has_merge_no_overlap_work_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000008U);
  return value;
}
inline void SatParameters::clear_merge_no_overlap_work_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.merge_no_overlap_work_limit_ = 1000000000000;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000008U);
}
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::set_merge_no_overlap_work_limit(double value) {
  _internal_set_merge_no_overlap_work_limit(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.merge_no_overlap_work_limit)
}
inline double SatParameters::_internal_merge_no_overlap_work_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.merge_no_overlap_work_limit_;
}
inline void SatParameters::_internal_set_merge_no_overlap_work_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.merge_no_overlap_work_limit_ = value;
}
 
// optional double merge_at_most_one_work_limit = 146 [default = 100000000];
inline bool SatParameters::has_merge_at_most_one_work_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000010U);
  return value;
}
inline void SatParameters::clear_merge_at_most_one_work_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.merge_at_most_one_work_limit_ = 100000000;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000010U);
}
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::set_merge_at_most_one_work_limit(double value) {
  _internal_set_merge_at_most_one_work_limit(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.merge_at_most_one_work_limit)
}
inline double SatParameters::_internal_merge_at_most_one_work_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.merge_at_most_one_work_limit_;
}
inline void SatParameters::_internal_set_merge_at_most_one_work_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.merge_at_most_one_work_limit_ = value;
}
 
// optional int32 presolve_substitution_level = 147 [default = 1];
inline bool SatParameters::has_presolve_substitution_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000020U);
  return value;
}
inline void SatParameters::clear_presolve_substitution_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_substitution_level_ = 1;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000020U);
}
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::set_presolve_substitution_level(::int32_t value) {
  _internal_set_presolve_substitution_level(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_substitution_level)
}
inline ::int32_t SatParameters::_internal_presolve_substitution_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_substitution_level_;
}
inline void SatParameters::_internal_set_presolve_substitution_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_substitution_level_ = value;
}
 
// optional bool presolve_extract_integer_enforcement = 174 [default = false];
inline bool SatParameters::has_presolve_extract_integer_enforcement() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000020U);
  return value;
}
inline void SatParameters::clear_presolve_extract_integer_enforcement() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_extract_integer_enforcement_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000020U);
}
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::set_presolve_extract_integer_enforcement(bool value) {
  _internal_set_presolve_extract_integer_enforcement(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_extract_integer_enforcement)
}
inline bool SatParameters::_internal_presolve_extract_integer_enforcement() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_extract_integer_enforcement_;
}
inline void SatParameters::_internal_set_presolve_extract_integer_enforcement(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_extract_integer_enforcement_ = value;
}
 
// optional int64 presolve_inclusion_work_limit = 201 [default = 100000000];
inline bool SatParameters::has_presolve_inclusion_work_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x10000000U);
  return value;
}
inline void SatParameters::clear_presolve_inclusion_work_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_inclusion_work_limit_ = ::int64_t{100000000};
  ClearHasBit(_impl_._has_bits_[6],
                  0x10000000U);
}
inline ::int64_t SatParameters::presolve_inclusion_work_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_inclusion_work_limit)
  return _internal_presolve_inclusion_work_limit();
}
inline void SatParameters::set_presolve_inclusion_work_limit(::int64_t value) {
  _internal_set_presolve_inclusion_work_limit(value);
  SetHasBit(_impl_._has_bits_[6], 0x10000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_inclusion_work_limit)
}
inline ::int64_t SatParameters::_internal_presolve_inclusion_work_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.presolve_inclusion_work_limit_;
}
inline void SatParameters::_internal_set_presolve_inclusion_work_limit(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_inclusion_work_limit_ = value;
}
 
// optional bool ignore_names = 202 [default = true];
inline bool SatParameters::has_ignore_names() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x80000000U);
  return value;
}
inline void SatParameters::clear_ignore_names() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ignore_names_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x80000000U);
}
inline bool SatParameters::ignore_names() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.ignore_names)
  return _internal_ignore_names();
}
inline void SatParameters::set_ignore_names(bool value) {
  _internal_set_ignore_names(value);
  SetHasBit(_impl_._has_bits_[6], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.ignore_names)
}
inline bool SatParameters::_internal_ignore_names() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ignore_names_;
}
inline void SatParameters::_internal_set_ignore_names(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ignore_names_ = value;
}
 
// optional bool infer_all_diffs = 233 [default = true];
inline bool SatParameters::has_infer_all_diffs() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00001000U);
  return value;
}
inline void SatParameters::clear_infer_all_diffs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.infer_all_diffs_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00001000U);
}
inline bool SatParameters::infer_all_diffs() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.infer_all_diffs)
  return _internal_infer_all_diffs();
}
inline void SatParameters::set_infer_all_diffs(bool value) {
  _internal_set_infer_all_diffs(value);
  SetHasBit(_impl_._has_bits_[7], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.infer_all_diffs)
}
inline bool SatParameters::_internal_infer_all_diffs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.infer_all_diffs_;
}
inline void SatParameters::_internal_set_infer_all_diffs(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.infer_all_diffs_ = value;
}
 
// optional bool find_big_linear_overlap = 234 [default = true];
inline bool SatParameters::has_find_big_linear_overlap() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00002000U);
  return value;
}
inline void SatParameters::clear_find_big_linear_overlap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.find_big_linear_overlap_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00002000U);
}
inline bool SatParameters::find_big_linear_overlap() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.find_big_linear_overlap)
  return _internal_find_big_linear_overlap();
}
inline void SatParameters::set_find_big_linear_overlap(bool value) {
  _internal_set_find_big_linear_overlap(value);
  SetHasBit(_impl_._has_bits_[7], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.find_big_linear_overlap)
}
inline bool SatParameters::_internal_find_big_linear_overlap() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.find_big_linear_overlap_;
}
inline void SatParameters::_internal_set_find_big_linear_overlap(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.find_big_linear_overlap_ = value;
}
 
// optional bool find_clauses_that_are_exactly_one = 333 [default = true];
inline bool SatParameters::has_find_clauses_that_are_exactly_one() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000080U);
  return value;
}
inline void SatParameters::clear_find_clauses_that_are_exactly_one() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.find_clauses_that_are_exactly_one_ = true;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000080U);
}
inline bool SatParameters::find_clauses_that_are_exactly_one() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.find_clauses_that_are_exactly_one)
  return _internal_find_clauses_that_are_exactly_one();
}
inline void SatParameters::set_find_clauses_that_are_exactly_one(bool value) {
  _internal_set_find_clauses_that_are_exactly_one(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.find_clauses_that_are_exactly_one)
}
inline bool SatParameters::_internal_find_clauses_that_are_exactly_one() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.find_clauses_that_are_exactly_one_;
}
inline void SatParameters::_internal_set_find_clauses_that_are_exactly_one(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.find_clauses_that_are_exactly_one_ = value;
}
 
// optional bool use_sat_inprocessing = 163 [default = true];
inline bool SatParameters::has_use_sat_inprocessing() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00004000U);
  return value;
}
inline void SatParameters::clear_use_sat_inprocessing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_sat_inprocessing_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00004000U);
}
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::set_use_sat_inprocessing(bool value) {
  _internal_set_use_sat_inprocessing(value);
  SetHasBit(_impl_._has_bits_[6], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_sat_inprocessing)
}
inline bool SatParameters::_internal_use_sat_inprocessing() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_sat_inprocessing_;
}
inline void SatParameters::_internal_set_use_sat_inprocessing(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_sat_inprocessing_ = value;
}
 
// optional double inprocessing_dtime_ratio = 273 [default = 0.2];
inline bool SatParameters::has_inprocessing_dtime_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000008U);
  return value;
}
inline void SatParameters::clear_inprocessing_dtime_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_dtime_ratio_ = 0.2;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000008U);
}
inline double SatParameters::inprocessing_dtime_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.inprocessing_dtime_ratio)
  return _internal_inprocessing_dtime_ratio();
}
inline void SatParameters::set_inprocessing_dtime_ratio(double value) {
  _internal_set_inprocessing_dtime_ratio(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.inprocessing_dtime_ratio)
}
inline double SatParameters::_internal_inprocessing_dtime_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.inprocessing_dtime_ratio_;
}
inline void SatParameters::_internal_set_inprocessing_dtime_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_dtime_ratio_ = value;
}
 
// optional double inprocessing_probing_dtime = 274 [default = 1];
inline bool SatParameters::has_inprocessing_probing_dtime() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000010U);
  return value;
}
inline void SatParameters::clear_inprocessing_probing_dtime() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_probing_dtime_ = 1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000010U);
}
inline double SatParameters::inprocessing_probing_dtime() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.inprocessing_probing_dtime)
  return _internal_inprocessing_probing_dtime();
}
inline void SatParameters::set_inprocessing_probing_dtime(double value) {
  _internal_set_inprocessing_probing_dtime(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.inprocessing_probing_dtime)
}
inline double SatParameters::_internal_inprocessing_probing_dtime() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.inprocessing_probing_dtime_;
}
inline void SatParameters::_internal_set_inprocessing_probing_dtime(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_probing_dtime_ = value;
}
 
// optional double inprocessing_minimization_dtime = 275 [default = 1];
inline bool SatParameters::has_inprocessing_minimization_dtime() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000020U);
  return value;
}
inline void SatParameters::clear_inprocessing_minimization_dtime() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_minimization_dtime_ = 1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000020U);
}
inline double SatParameters::inprocessing_minimization_dtime() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.inprocessing_minimization_dtime)
  return _internal_inprocessing_minimization_dtime();
}
inline void SatParameters::set_inprocessing_minimization_dtime(double value) {
  _internal_set_inprocessing_minimization_dtime(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.inprocessing_minimization_dtime)
}
inline double SatParameters::_internal_inprocessing_minimization_dtime() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.inprocessing_minimization_dtime_;
}
inline void SatParameters::_internal_set_inprocessing_minimization_dtime(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_minimization_dtime_ = value;
}
 
// optional bool inprocessing_minimization_use_conflict_analysis = 297 [default = true];
inline bool SatParameters::has_inprocessing_minimization_use_conflict_analysis() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00002000U);
  return value;
}
inline void SatParameters::clear_inprocessing_minimization_use_conflict_analysis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_minimization_use_conflict_analysis_ = true;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00002000U);
}
inline bool SatParameters::inprocessing_minimization_use_conflict_analysis() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.inprocessing_minimization_use_conflict_analysis)
  return _internal_inprocessing_minimization_use_conflict_analysis();
}
inline void SatParameters::set_inprocessing_minimization_use_conflict_analysis(bool value) {
  _internal_set_inprocessing_minimization_use_conflict_analysis(value);
  SetHasBit(_impl_._has_bits_[8], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.inprocessing_minimization_use_conflict_analysis)
}
inline bool SatParameters::_internal_inprocessing_minimization_use_conflict_analysis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.inprocessing_minimization_use_conflict_analysis_;
}
inline void SatParameters::_internal_set_inprocessing_minimization_use_conflict_analysis(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_minimization_use_conflict_analysis_ = value;
}
 
// optional bool inprocessing_minimization_use_all_orderings = 298 [default = false];
inline bool SatParameters::has_inprocessing_minimization_use_all_orderings() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00020000U);
  return value;
}
inline void SatParameters::clear_inprocessing_minimization_use_all_orderings() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_minimization_use_all_orderings_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00020000U);
}
inline bool SatParameters::inprocessing_minimization_use_all_orderings() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.inprocessing_minimization_use_all_orderings)
  return _internal_inprocessing_minimization_use_all_orderings();
}
inline void SatParameters::set_inprocessing_minimization_use_all_orderings(bool value) {
  _internal_set_inprocessing_minimization_use_all_orderings(value);
  SetHasBit(_impl_._has_bits_[3], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.inprocessing_minimization_use_all_orderings)
}
inline bool SatParameters::_internal_inprocessing_minimization_use_all_orderings() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.inprocessing_minimization_use_all_orderings_;
}
inline void SatParameters::_internal_set_inprocessing_minimization_use_all_orderings(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_minimization_use_all_orderings_ = value;
}
 
// optional bool inprocessing_use_congruence_closure = 342 [default = true];
inline bool SatParameters::has_inprocessing_use_congruence_closure() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000200U);
  return value;
}
inline void SatParameters::clear_inprocessing_use_congruence_closure() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_use_congruence_closure_ = true;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000200U);
}
inline bool SatParameters::inprocessing_use_congruence_closure() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.inprocessing_use_congruence_closure)
  return _internal_inprocessing_use_congruence_closure();
}
inline void SatParameters::set_inprocessing_use_congruence_closure(bool value) {
  _internal_set_inprocessing_use_congruence_closure(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.inprocessing_use_congruence_closure)
}
inline bool SatParameters::_internal_inprocessing_use_congruence_closure() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.inprocessing_use_congruence_closure_;
}
inline void SatParameters::_internal_set_inprocessing_use_congruence_closure(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_use_congruence_closure_ = value;
}
 
// optional bool inprocessing_use_sat_sweeping = 354 [default = false];
inline bool SatParameters::has_inprocessing_use_sat_sweeping() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000200U);
  return value;
}
inline void SatParameters::clear_inprocessing_use_sat_sweeping() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_use_sat_sweeping_ = false;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000200U);
}
inline bool SatParameters::inprocessing_use_sat_sweeping() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.inprocessing_use_sat_sweeping)
  return _internal_inprocessing_use_sat_sweeping();
}
inline void SatParameters::set_inprocessing_use_sat_sweeping(bool value) {
  _internal_set_inprocessing_use_sat_sweeping(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.inprocessing_use_sat_sweeping)
}
inline bool SatParameters::_internal_inprocessing_use_sat_sweeping() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.inprocessing_use_sat_sweeping_;
}
inline void SatParameters::_internal_set_inprocessing_use_sat_sweeping(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.inprocessing_use_sat_sweeping_ = value;
}
 
// optional int32 num_workers = 206 [default = 0];
inline bool SatParameters::has_num_workers() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00080000U);
  return value;
}
inline void SatParameters::clear_num_workers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_workers_ = 0;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00080000U);
}
inline ::int32_t SatParameters::num_workers() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_workers)
  return _internal_num_workers();
}
inline void SatParameters::set_num_workers(::int32_t value) {
  _internal_set_num_workers(value);
  SetHasBit(_impl_._has_bits_[2], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_workers)
}
inline ::int32_t SatParameters::_internal_num_workers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_workers_;
}
inline void SatParameters::_internal_set_num_workers(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_workers_ = value;
}
 
// optional int32 num_search_workers = 100 [default = 0];
inline bool SatParameters::has_num_search_workers() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00040000U);
  return value;
}
inline void SatParameters::clear_num_search_workers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_search_workers_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00040000U);
}
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::set_num_search_workers(::int32_t value) {
  _internal_set_num_search_workers(value);
  SetHasBit(_impl_._has_bits_[1], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_search_workers)
}
inline ::int32_t SatParameters::_internal_num_search_workers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_search_workers_;
}
inline void SatParameters::_internal_set_num_search_workers(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_search_workers_ = value;
}
 
// optional int32 num_full_subsolvers = 294 [default = 0];
inline bool SatParameters::has_num_full_subsolvers() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00010000U);
  return value;
}
inline void SatParameters::clear_num_full_subsolvers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_full_subsolvers_ = 0;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00010000U);
}
inline ::int32_t SatParameters::num_full_subsolvers() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_full_subsolvers)
  return _internal_num_full_subsolvers();
}
inline void SatParameters::set_num_full_subsolvers(::int32_t value) {
  _internal_set_num_full_subsolvers(value);
  SetHasBit(_impl_._has_bits_[3], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_full_subsolvers)
}
inline ::int32_t SatParameters::_internal_num_full_subsolvers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_full_subsolvers_;
}
inline void SatParameters::_internal_set_num_full_subsolvers(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_full_subsolvers_ = value;
}
 
// repeated string subsolvers = 207;
inline int SatParameters::_internal_subsolvers_size() const {
  return _internal_subsolvers().size();
}
inline int SatParameters::subsolvers_size() const {
  return _internal_subsolvers_size();
}
inline void SatParameters::clear_subsolvers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.subsolvers_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00800000U);
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::add_subsolvers()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_subsolvers()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_add_mutable:operations_research.sat.SatParameters.subsolvers)
  return _s;
}
inline const ::std::string& SatParameters::subsolvers(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.subsolvers)
  return _internal_subsolvers().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::mutable_subsolvers(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.subsolvers)
  return _internal_mutable_subsolvers()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void SatParameters::set_subsolvers(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_subsolvers()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.subsolvers)
}
template <typename Arg_, typename... Args_>
inline void SatParameters::add_subsolvers(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_subsolvers(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.subsolvers)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& SatParameters::subsolvers()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.subsolvers)
  return _internal_subsolvers();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
SatParameters::mutable_subsolvers() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.subsolvers)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_subsolvers();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
SatParameters::_internal_subsolvers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.subsolvers_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
SatParameters::_internal_mutable_subsolvers() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.subsolvers_;
}
 
// repeated string extra_subsolvers = 219;
inline int SatParameters::_internal_extra_subsolvers_size() const {
  return _internal_extra_subsolvers().size();
}
inline int SatParameters::extra_subsolvers_size() const {
  return _internal_extra_subsolvers_size();
}
inline void SatParameters::clear_extra_subsolvers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.extra_subsolvers_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x04000000U);
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::add_extra_subsolvers()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_extra_subsolvers()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x04000000U);
  // @@protoc_insertion_point(field_add_mutable:operations_research.sat.SatParameters.extra_subsolvers)
  return _s;
}
inline const ::std::string& SatParameters::extra_subsolvers(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.extra_subsolvers)
  return _internal_extra_subsolvers().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::mutable_extra_subsolvers(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.extra_subsolvers)
  return _internal_mutable_extra_subsolvers()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void SatParameters::set_extra_subsolvers(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_extra_subsolvers()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.extra_subsolvers)
}
template <typename Arg_, typename... Args_>
inline void SatParameters::add_extra_subsolvers(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_extra_subsolvers(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x04000000U);
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.extra_subsolvers)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& SatParameters::extra_subsolvers()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.extra_subsolvers)
  return _internal_extra_subsolvers();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
SatParameters::mutable_extra_subsolvers() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x04000000U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.extra_subsolvers)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_extra_subsolvers();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
SatParameters::_internal_extra_subsolvers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.extra_subsolvers_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
SatParameters::_internal_mutable_extra_subsolvers() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.extra_subsolvers_;
}
 
// repeated string ignore_subsolvers = 209;
inline int SatParameters::_internal_ignore_subsolvers_size() const {
  return _internal_ignore_subsolvers().size();
}
inline int SatParameters::ignore_subsolvers_size() const {
  return _internal_ignore_subsolvers_size();
}
inline void SatParameters::clear_ignore_subsolvers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ignore_subsolvers_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x01000000U);
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::add_ignore_subsolvers()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_ignore_subsolvers()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_add_mutable:operations_research.sat.SatParameters.ignore_subsolvers)
  return _s;
}
inline const ::std::string& SatParameters::ignore_subsolvers(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.ignore_subsolvers)
  return _internal_ignore_subsolvers().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::mutable_ignore_subsolvers(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.ignore_subsolvers)
  return _internal_mutable_ignore_subsolvers()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void SatParameters::set_ignore_subsolvers(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_ignore_subsolvers()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.ignore_subsolvers)
}
template <typename Arg_, typename... Args_>
inline void SatParameters::add_ignore_subsolvers(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_ignore_subsolvers(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.ignore_subsolvers)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& SatParameters::ignore_subsolvers()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.ignore_subsolvers)
  return _internal_ignore_subsolvers();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
SatParameters::mutable_ignore_subsolvers() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.ignore_subsolvers)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_ignore_subsolvers();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
SatParameters::_internal_ignore_subsolvers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ignore_subsolvers_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
SatParameters::_internal_mutable_ignore_subsolvers() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.ignore_subsolvers_;
}
 
// repeated string filter_subsolvers = 293;
inline int SatParameters::_internal_filter_subsolvers_size() const {
  return _internal_filter_subsolvers().size();
}
inline int SatParameters::filter_subsolvers_size() const {
  return _internal_filter_subsolvers_size();
}
inline void SatParameters::clear_filter_subsolvers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.filter_subsolvers_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x08000000U);
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::add_filter_subsolvers()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_filter_subsolvers()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x08000000U);
  // @@protoc_insertion_point(field_add_mutable:operations_research.sat.SatParameters.filter_subsolvers)
  return _s;
}
inline const ::std::string& SatParameters::filter_subsolvers(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.filter_subsolvers)
  return _internal_filter_subsolvers().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL SatParameters::mutable_filter_subsolvers(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.filter_subsolvers)
  return _internal_mutable_filter_subsolvers()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void SatParameters::set_filter_subsolvers(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(*_internal_mutable_filter_subsolvers()->Mutable(index), ::std::forward<Arg_>(value),
                        args... );
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.filter_subsolvers)
}
template <typename Arg_, typename... Args_>
inline void SatParameters::add_filter_subsolvers(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_filter_subsolvers(), ::std::forward<Arg_>(value),
      args... );
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x08000000U);
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.filter_subsolvers)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& SatParameters::filter_subsolvers()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.filter_subsolvers)
  return _internal_filter_subsolvers();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
SatParameters::mutable_filter_subsolvers() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x08000000U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.filter_subsolvers)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_filter_subsolvers();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
SatParameters::_internal_filter_subsolvers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.filter_subsolvers_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
SatParameters::_internal_mutable_filter_subsolvers() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.filter_subsolvers_;
}
 
// repeated .operations_research.sat.SatParameters subsolver_params = 210;
inline int SatParameters::_internal_subsolver_params_size() const {
  return _internal_subsolver_params().size();
}
inline int SatParameters::subsolver_params_size() const {
  return _internal_subsolver_params_size();
}
inline void SatParameters::clear_subsolver_params() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.subsolver_params_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x02000000U);
}
inline ::operations_research::sat::SatParameters* PROTOBUF_NONNULL SatParameters::mutable_subsolver_params(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.subsolver_params)
  return _internal_mutable_subsolver_params()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::operations_research::sat::SatParameters>* PROTOBUF_NONNULL SatParameters::mutable_subsolver_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x02000000U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.subsolver_params)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_subsolver_params();
}
inline const ::operations_research::sat::SatParameters& SatParameters::subsolver_params(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.subsolver_params)
  return _internal_subsolver_params().Get(index);
}
inline ::operations_research::sat::SatParameters* PROTOBUF_NONNULL SatParameters::add_subsolver_params()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::operations_research::sat::SatParameters* _add =
      _internal_mutable_subsolver_params()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x02000000U);
  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.subsolver_params)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::operations_research::sat::SatParameters>& SatParameters::subsolver_params() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.subsolver_params)
  return _internal_subsolver_params();
}
inline const ::google::protobuf::RepeatedPtrField<::operations_research::sat::SatParameters>&
SatParameters::_internal_subsolver_params() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.subsolver_params_;
}
inline ::google::protobuf::RepeatedPtrField<::operations_research::sat::SatParameters>* PROTOBUF_NONNULL
SatParameters::_internal_mutable_subsolver_params() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.subsolver_params_;
}
 
// optional bool interleave_search = 136 [default = false];
inline bool SatParameters::has_interleave_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x08000000U);
  return value;
}
inline void SatParameters::clear_interleave_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.interleave_search_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x08000000U);
}
inline bool SatParameters::interleave_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.interleave_search)
  return _internal_interleave_search();
}
inline void SatParameters::set_interleave_search(bool value) {
  _internal_set_interleave_search(value);
  SetHasBit(_impl_._has_bits_[1], 0x08000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_search)
}
inline bool SatParameters::_internal_interleave_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.interleave_search_;
}
inline void SatParameters::_internal_set_interleave_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.interleave_search_ = value;
}
 
// optional int32 interleave_batch_size = 134 [default = 0];
inline bool SatParameters::has_interleave_batch_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x01000000U);
  return value;
}
inline void SatParameters::clear_interleave_batch_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.interleave_batch_size_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x01000000U);
}
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::set_interleave_batch_size(::int32_t value) {
  _internal_set_interleave_batch_size(value);
  SetHasBit(_impl_._has_bits_[1], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_batch_size)
}
inline ::int32_t SatParameters::_internal_interleave_batch_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.interleave_batch_size_;
}
inline void SatParameters::_internal_set_interleave_batch_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.interleave_batch_size_ = value;
}
 
// optional bool share_objective_bounds = 113 [default = true];
inline bool SatParameters::has_share_objective_bounds() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00004000U);
  return value;
}
inline void SatParameters::clear_share_objective_bounds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_objective_bounds_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00004000U);
}
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::set_share_objective_bounds(bool value) {
  _internal_set_share_objective_bounds(value);
  SetHasBit(_impl_._has_bits_[5], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_objective_bounds)
}
inline bool SatParameters::_internal_share_objective_bounds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.share_objective_bounds_;
}
inline void SatParameters::_internal_set_share_objective_bounds(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_objective_bounds_ = value;
}
 
// optional bool share_level_zero_bounds = 114 [default = true];
inline bool SatParameters::has_share_level_zero_bounds() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00008000U);
  return value;
}
inline void SatParameters::clear_share_level_zero_bounds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_level_zero_bounds_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00008000U);
}
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::set_share_level_zero_bounds(bool value) {
  _internal_set_share_level_zero_bounds(value);
  SetHasBit(_impl_._has_bits_[5], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_level_zero_bounds)
}
inline bool SatParameters::_internal_share_level_zero_bounds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.share_level_zero_bounds_;
}
inline void SatParameters::_internal_set_share_level_zero_bounds(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_level_zero_bounds_ = value;
}
 
// optional bool share_linear2_bounds = 326 [default = false];
inline bool SatParameters::has_share_linear2_bounds() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x10000000U);
  return value;
}
inline void SatParameters::clear_share_linear2_bounds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_linear2_bounds_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x10000000U);
}
inline bool SatParameters::share_linear2_bounds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_linear2_bounds)
  return _internal_share_linear2_bounds();
}
inline void SatParameters::set_share_linear2_bounds(bool value) {
  _internal_set_share_linear2_bounds(value);
  SetHasBit(_impl_._has_bits_[3], 0x10000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_linear2_bounds)
}
inline bool SatParameters::_internal_share_linear2_bounds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.share_linear2_bounds_;
}
inline void SatParameters::_internal_set_share_linear2_bounds(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_linear2_bounds_ = value;
}
 
// optional bool share_binary_clauses = 203 [default = true];
inline bool SatParameters::has_share_binary_clauses() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000001U);
  return value;
}
inline void SatParameters::clear_share_binary_clauses() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_binary_clauses_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000001U);
}
inline bool SatParameters::share_binary_clauses() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_binary_clauses)
  return _internal_share_binary_clauses();
}
inline void SatParameters::set_share_binary_clauses(bool value) {
  _internal_set_share_binary_clauses(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_binary_clauses)
}
inline bool SatParameters::_internal_share_binary_clauses() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.share_binary_clauses_;
}
inline void SatParameters::_internal_set_share_binary_clauses(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_binary_clauses_ = value;
}
 
// optional bool share_glue_clauses = 285 [default = true];
inline bool SatParameters::has_share_glue_clauses() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000800U);
  return value;
}
inline void SatParameters::clear_share_glue_clauses() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_glue_clauses_ = true;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000800U);
}
inline bool SatParameters::share_glue_clauses() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_glue_clauses)
  return _internal_share_glue_clauses();
}
inline void SatParameters::set_share_glue_clauses(bool value) {
  _internal_set_share_glue_clauses(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_glue_clauses)
}
inline bool SatParameters::_internal_share_glue_clauses() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.share_glue_clauses_;
}
inline void SatParameters::_internal_set_share_glue_clauses(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_glue_clauses_ = value;
}
 
// optional bool minimize_shared_clauses = 300 [default = true];
inline bool SatParameters::has_minimize_shared_clauses() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00200000U);
  return value;
}
inline void SatParameters::clear_minimize_shared_clauses() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minimize_shared_clauses_ = true;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00200000U);
}
inline bool SatParameters::minimize_shared_clauses() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_shared_clauses)
  return _internal_minimize_shared_clauses();
}
inline void SatParameters::set_minimize_shared_clauses(bool value) {
  _internal_set_minimize_shared_clauses(value);
  SetHasBit(_impl_._has_bits_[8], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_shared_clauses)
}
inline bool SatParameters::_internal_minimize_shared_clauses() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.minimize_shared_clauses_;
}
inline void SatParameters::_internal_set_minimize_shared_clauses(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.minimize_shared_clauses_ = value;
}
 
// optional double share_glue_clauses_dtime = 322 [default = 1];
inline bool SatParameters::has_share_glue_clauses_dtime() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x80000000U);
  return value;
}
inline void SatParameters::clear_share_glue_clauses_dtime() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_glue_clauses_dtime_ = 1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x80000000U);
}
inline double SatParameters::share_glue_clauses_dtime() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_glue_clauses_dtime)
  return _internal_share_glue_clauses_dtime();
}
inline void SatParameters::set_share_glue_clauses_dtime(double value) {
  _internal_set_share_glue_clauses_dtime(value);
  SetHasBit(_impl_._has_bits_[8], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_glue_clauses_dtime)
}
inline double SatParameters::_internal_share_glue_clauses_dtime() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.share_glue_clauses_dtime_;
}
inline void SatParameters::_internal_set_share_glue_clauses_dtime(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.share_glue_clauses_dtime_ = value;
}
 
// optional bool check_lrat_proof = 344 [default = false];
inline bool SatParameters::has_check_lrat_proof() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000004U);
  return value;
}
inline void SatParameters::clear_check_lrat_proof() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.check_lrat_proof_ = false;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000004U);
}
inline bool SatParameters::check_lrat_proof() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.check_lrat_proof)
  return _internal_check_lrat_proof();
}
inline void SatParameters::set_check_lrat_proof(bool value) {
  _internal_set_check_lrat_proof(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.check_lrat_proof)
}
inline bool SatParameters::_internal_check_lrat_proof() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.check_lrat_proof_;
}
inline void SatParameters::_internal_set_check_lrat_proof(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.check_lrat_proof_ = value;
}
 
// optional bool check_merged_lrat_proof = 352 [default = false];
inline bool SatParameters::has_check_merged_lrat_proof() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000100U);
  return value;
}
inline void SatParameters::clear_check_merged_lrat_proof() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.check_merged_lrat_proof_ = false;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000100U);
}
inline bool SatParameters::check_merged_lrat_proof() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.check_merged_lrat_proof)
  return _internal_check_merged_lrat_proof();
}
inline void SatParameters::set_check_merged_lrat_proof(bool value) {
  _internal_set_check_merged_lrat_proof(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.check_merged_lrat_proof)
}
inline bool SatParameters::_internal_check_merged_lrat_proof() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.check_merged_lrat_proof_;
}
inline void SatParameters::_internal_set_check_merged_lrat_proof(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.check_merged_lrat_proof_ = value;
}
 
// optional bool output_lrat_proof = 345 [default = false];
inline bool SatParameters::has_output_lrat_proof() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000008U);
  return value;
}
inline void SatParameters::clear_output_lrat_proof() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_lrat_proof_ = false;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000008U);
}
inline bool SatParameters::output_lrat_proof() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.output_lrat_proof)
  return _internal_output_lrat_proof();
}
inline void SatParameters::set_output_lrat_proof(bool value) {
  _internal_set_output_lrat_proof(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.output_lrat_proof)
}
inline bool SatParameters::_internal_output_lrat_proof() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_lrat_proof_;
}
inline void SatParameters::_internal_set_output_lrat_proof(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_lrat_proof_ = value;
}
 
// optional bool check_drat_proof = 346 [default = false];
inline bool SatParameters::has_check_drat_proof() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000010U);
  return value;
}
inline void SatParameters::clear_check_drat_proof() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.check_drat_proof_ = false;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000010U);
}
inline bool SatParameters::check_drat_proof() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.check_drat_proof)
  return _internal_check_drat_proof();
}
inline void SatParameters::set_check_drat_proof(bool value) {
  _internal_set_check_drat_proof(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.check_drat_proof)
}
inline bool SatParameters::_internal_check_drat_proof() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.check_drat_proof_;
}
inline void SatParameters::_internal_set_check_drat_proof(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.check_drat_proof_ = value;
}
 
// optional bool output_drat_proof = 347 [default = false];
inline bool SatParameters::has_output_drat_proof() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000080U);
  return value;
}
inline void SatParameters::clear_output_drat_proof() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_drat_proof_ = false;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000080U);
}
inline bool SatParameters::output_drat_proof() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.output_drat_proof)
  return _internal_output_drat_proof();
}
inline void SatParameters::set_output_drat_proof(bool value) {
  _internal_set_output_drat_proof(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.output_drat_proof)
}
inline bool SatParameters::_internal_output_drat_proof() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.output_drat_proof_;
}
inline void SatParameters::_internal_set_output_drat_proof(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.output_drat_proof_ = value;
}
 
// optional double max_drat_time_in_seconds = 348 [default = inf];
inline bool SatParameters::has_max_drat_time_in_seconds() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00001000U);
  return value;
}
inline void SatParameters::clear_max_drat_time_in_seconds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_drat_time_in_seconds_ = std::numeric_limits<double>::infinity();
  ClearHasBit(_impl_._has_bits_[9],
                  0x00001000U);
}
inline double SatParameters::max_drat_time_in_seconds() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_drat_time_in_seconds)
  return _internal_max_drat_time_in_seconds();
}
inline void SatParameters::set_max_drat_time_in_seconds(double value) {
  _internal_set_max_drat_time_in_seconds(value);
  SetHasBit(_impl_._has_bits_[9], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_drat_time_in_seconds)
}
inline double SatParameters::_internal_max_drat_time_in_seconds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_drat_time_in_seconds_;
}
inline void SatParameters::_internal_set_max_drat_time_in_seconds(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_drat_time_in_seconds_ = value;
}
 
// optional bool debug_postsolve_with_full_solver = 162 [default = false];
inline bool SatParameters::has_debug_postsolve_with_full_solver() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000002U);
  return value;
}
inline void SatParameters::clear_debug_postsolve_with_full_solver() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_postsolve_with_full_solver_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000002U);
}
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::set_debug_postsolve_with_full_solver(bool value) {
  _internal_set_debug_postsolve_with_full_solver(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.debug_postsolve_with_full_solver)
}
inline bool SatParameters::_internal_debug_postsolve_with_full_solver() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.debug_postsolve_with_full_solver_;
}
inline void SatParameters::_internal_set_debug_postsolve_with_full_solver(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_postsolve_with_full_solver_ = value;
}
 
// optional int32 debug_max_num_presolve_operations = 151 [default = 0];
inline bool SatParameters::has_debug_max_num_presolve_operations() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x20000000U);
  return value;
}
inline void SatParameters::clear_debug_max_num_presolve_operations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_max_num_presolve_operations_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x20000000U);
}
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::set_debug_max_num_presolve_operations(::int32_t value) {
  _internal_set_debug_max_num_presolve_operations(value);
  SetHasBit(_impl_._has_bits_[1], 0x20000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.debug_max_num_presolve_operations)
}
inline ::int32_t SatParameters::_internal_debug_max_num_presolve_operations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.debug_max_num_presolve_operations_;
}
inline void SatParameters::_internal_set_debug_max_num_presolve_operations(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_max_num_presolve_operations_ = value;
}
 
// optional bool debug_crash_on_bad_hint = 195 [default = false];
inline bool SatParameters::has_debug_crash_on_bad_hint() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00020000U);
  return value;
}
inline void SatParameters::clear_debug_crash_on_bad_hint() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_crash_on_bad_hint_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00020000U);
}
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::set_debug_crash_on_bad_hint(bool value) {
  _internal_set_debug_crash_on_bad_hint(value);
  SetHasBit(_impl_._has_bits_[2], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.debug_crash_on_bad_hint)
}
inline bool SatParameters::_internal_debug_crash_on_bad_hint() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.debug_crash_on_bad_hint_;
}
inline void SatParameters::_internal_set_debug_crash_on_bad_hint(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_crash_on_bad_hint_ = value;
}
 
// optional bool debug_crash_if_presolve_breaks_hint = 306 [default = false];
inline bool SatParameters::has_debug_crash_if_presolve_breaks_hint() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00400000U);
  return value;
}
inline void SatParameters::clear_debug_crash_if_presolve_breaks_hint() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_crash_if_presolve_breaks_hint_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00400000U);
}
inline bool SatParameters::debug_crash_if_presolve_breaks_hint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.debug_crash_if_presolve_breaks_hint)
  return _internal_debug_crash_if_presolve_breaks_hint();
}
inline void SatParameters::set_debug_crash_if_presolve_breaks_hint(bool value) {
  _internal_set_debug_crash_if_presolve_breaks_hint(value);
  SetHasBit(_impl_._has_bits_[3], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.debug_crash_if_presolve_breaks_hint)
}
inline bool SatParameters::_internal_debug_crash_if_presolve_breaks_hint() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.debug_crash_if_presolve_breaks_hint_;
}
inline void SatParameters::_internal_set_debug_crash_if_presolve_breaks_hint(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_crash_if_presolve_breaks_hint_ = value;
}
 
// optional bool debug_crash_if_lrat_check_fails = 339 [default = false];
inline bool SatParameters::has_debug_crash_if_lrat_check_fails() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00000002U);
  return value;
}
inline void SatParameters::clear_debug_crash_if_lrat_check_fails() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_crash_if_lrat_check_fails_ = false;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00000002U);
}
inline bool SatParameters::debug_crash_if_lrat_check_fails() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.debug_crash_if_lrat_check_fails)
  return _internal_debug_crash_if_lrat_check_fails();
}
inline void SatParameters::set_debug_crash_if_lrat_check_fails(bool value) {
  _internal_set_debug_crash_if_lrat_check_fails(value);
  SetHasBit(_impl_._has_bits_[4], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.debug_crash_if_lrat_check_fails)
}
inline bool SatParameters::_internal_debug_crash_if_lrat_check_fails() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.debug_crash_if_lrat_check_fails_;
}
inline void SatParameters::_internal_set_debug_crash_if_lrat_check_fails(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.debug_crash_if_lrat_check_fails_ = value;
}
 
// optional bool use_optimization_hints = 35 [default = true];
inline bool SatParameters::has_use_optimization_hints() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void SatParameters::clear_use_optimization_hints() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_optimization_hints_ = true;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000020U);
}
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::set_use_optimization_hints(bool value) {
  _internal_set_use_optimization_hints(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_optimization_hints)
}
inline bool SatParameters::_internal_use_optimization_hints() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_optimization_hints_;
}
inline void SatParameters::_internal_set_use_optimization_hints(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_optimization_hints_ = value;
}
 
// optional int32 core_minimization_level = 50 [default = 2];
inline bool SatParameters::has_core_minimization_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00004000U);
  return value;
}
inline void SatParameters::clear_core_minimization_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.core_minimization_level_ = 2;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00004000U);
}
inline ::int32_t SatParameters::core_minimization_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.core_minimization_level)
  return _internal_core_minimization_level();
}
inline void SatParameters::set_core_minimization_level(::int32_t value) {
  _internal_set_core_minimization_level(value);
  SetHasBit(_impl_._has_bits_[4], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.core_minimization_level)
}
inline ::int32_t SatParameters::_internal_core_minimization_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.core_minimization_level_;
}
inline void SatParameters::_internal_set_core_minimization_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.core_minimization_level_ = value;
}
 
// optional bool find_multiple_cores = 84 [default = true];
inline bool SatParameters::has_find_multiple_cores() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x80000000U);
  return value;
}
inline void SatParameters::clear_find_multiple_cores() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.find_multiple_cores_ = true;
  ClearHasBit(_impl_._has_bits_[4],
                  0x80000000U);
}
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::set_find_multiple_cores(bool value) {
  _internal_set_find_multiple_cores(value);
  SetHasBit(_impl_._has_bits_[4], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.find_multiple_cores)
}
inline bool SatParameters::_internal_find_multiple_cores() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.find_multiple_cores_;
}
inline void SatParameters::_internal_set_find_multiple_cores(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.find_multiple_cores_ = value;
}
 
// optional bool cover_optimization = 89 [default = true];
inline bool SatParameters::has_cover_optimization() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000004U);
  return value;
}
inline void SatParameters::clear_cover_optimization() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cover_optimization_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000004U);
}
inline bool SatParameters::cover_optimization() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cover_optimization)
  return _internal_cover_optimization();
}
inline void SatParameters::set_cover_optimization(bool value) {
  _internal_set_cover_optimization(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cover_optimization)
}
inline bool SatParameters::_internal_cover_optimization() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cover_optimization_;
}
inline void SatParameters::_internal_set_cover_optimization(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cover_optimization_ = value;
}
 
// optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
inline bool SatParameters::has_max_sat_assumption_order() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000001U);
  return value;
}
inline void SatParameters::clear_max_sat_assumption_order() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_sat_assumption_order_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000001U);
}
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::set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value) {
  _internal_set_max_sat_assumption_order(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_assumption_order)
}
inline ::operations_research::sat::SatParameters_MaxSatAssumptionOrder SatParameters::_internal_max_sat_assumption_order() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_MaxSatAssumptionOrder>(_impl_.max_sat_assumption_order_);
}
inline void SatParameters::_internal_set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_MaxSatAssumptionOrder_internal_data_));
                                          _impl_.max_sat_assumption_order_ = value;
}
 
// optional bool max_sat_reverse_assumption_order = 52 [default = false];
inline bool SatParameters::has_max_sat_reverse_assumption_order() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000004U);
  return value;
}
inline void SatParameters::clear_max_sat_reverse_assumption_order() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_sat_reverse_assumption_order_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000004U);
}
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::set_max_sat_reverse_assumption_order(bool value) {
  _internal_set_max_sat_reverse_assumption_order(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_reverse_assumption_order)
}
inline bool SatParameters::_internal_max_sat_reverse_assumption_order() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_sat_reverse_assumption_order_;
}
inline void SatParameters::_internal_set_max_sat_reverse_assumption_order(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_sat_reverse_assumption_order_ = value;
}
 
// optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
inline bool SatParameters::has_max_sat_stratification() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x00008000U);
  return value;
}
inline void SatParameters::clear_max_sat_stratification() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_sat_stratification_ = 1;
  ClearHasBit(_impl_._has_bits_[4],
                  0x00008000U);
}
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::set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
  _internal_set_max_sat_stratification(value);
  SetHasBit(_impl_._has_bits_[4], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_stratification)
}
inline ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm SatParameters::_internal_max_sat_stratification() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm>(_impl_.max_sat_stratification_);
}
inline void SatParameters::_internal_set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_internal_data_));
                                          _impl_.max_sat_stratification_ = value;
}
 
// optional double propagation_loop_detection_factor = 221 [default = 10];
inline bool SatParameters::has_propagation_loop_detection_factor() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000010U);
  return value;
}
inline void SatParameters::clear_propagation_loop_detection_factor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.propagation_loop_detection_factor_ = 10;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000010U);
}
inline double SatParameters::propagation_loop_detection_factor() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.propagation_loop_detection_factor)
  return _internal_propagation_loop_detection_factor();
}
inline void SatParameters::set_propagation_loop_detection_factor(double value) {
  _internal_set_propagation_loop_detection_factor(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.propagation_loop_detection_factor)
}
inline double SatParameters::_internal_propagation_loop_detection_factor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.propagation_loop_detection_factor_;
}
inline void SatParameters::_internal_set_propagation_loop_detection_factor(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.propagation_loop_detection_factor_ = value;
}
 
// optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
inline bool SatParameters::has_use_precedences_in_disjunctive_constraint() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void SatParameters::clear_use_precedences_in_disjunctive_constraint() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_precedences_in_disjunctive_constraint_ = true;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000080U);
}
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::set_use_precedences_in_disjunctive_constraint(bool value) {
  _internal_set_use_precedences_in_disjunctive_constraint(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_precedences_in_disjunctive_constraint)
}
inline bool SatParameters::_internal_use_precedences_in_disjunctive_constraint() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_precedences_in_disjunctive_constraint_;
}
inline void SatParameters::_internal_set_use_precedences_in_disjunctive_constraint(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_precedences_in_disjunctive_constraint_ = value;
}
 
// optional int32 transitive_precedences_work_limit = 327 [default = 1000000];
inline bool SatParameters::has_transitive_precedences_work_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000002U);
  return value;
}
inline void SatParameters::clear_transitive_precedences_work_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transitive_precedences_work_limit_ = 1000000;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000002U);
}
inline ::int32_t SatParameters::transitive_precedences_work_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.transitive_precedences_work_limit)
  return _internal_transitive_precedences_work_limit();
}
inline void SatParameters::set_transitive_precedences_work_limit(::int32_t value) {
  _internal_set_transitive_precedences_work_limit(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.transitive_precedences_work_limit)
}
inline ::int32_t SatParameters::_internal_transitive_precedences_work_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.transitive_precedences_work_limit_;
}
inline void SatParameters::_internal_set_transitive_precedences_work_limit(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.transitive_precedences_work_limit_ = value;
}
 
// optional int32 max_size_to_create_precedence_literals_in_disjunctive = 229 [default = 60];
inline bool SatParameters::has_max_size_to_create_precedence_literals_in_disjunctive() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000200U);
  return value;
}
inline void SatParameters::clear_max_size_to_create_precedence_literals_in_disjunctive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_size_to_create_precedence_literals_in_disjunctive_ = 60;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000200U);
}
inline ::int32_t SatParameters::max_size_to_create_precedence_literals_in_disjunctive() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_size_to_create_precedence_literals_in_disjunctive)
  return _internal_max_size_to_create_precedence_literals_in_disjunctive();
}
inline void SatParameters::set_max_size_to_create_precedence_literals_in_disjunctive(::int32_t value) {
  _internal_set_max_size_to_create_precedence_literals_in_disjunctive(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_size_to_create_precedence_literals_in_disjunctive)
}
inline ::int32_t SatParameters::_internal_max_size_to_create_precedence_literals_in_disjunctive() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_size_to_create_precedence_literals_in_disjunctive_;
}
inline void SatParameters::_internal_set_max_size_to_create_precedence_literals_in_disjunctive(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_size_to_create_precedence_literals_in_disjunctive_ = value;
}
 
// optional bool use_strong_propagation_in_disjunctive = 230 [default = false];
inline bool SatParameters::has_use_strong_propagation_in_disjunctive() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x20000000U);
  return value;
}
inline void SatParameters::clear_use_strong_propagation_in_disjunctive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_strong_propagation_in_disjunctive_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x20000000U);
}
inline bool SatParameters::use_strong_propagation_in_disjunctive() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_strong_propagation_in_disjunctive)
  return _internal_use_strong_propagation_in_disjunctive();
}
inline void SatParameters::set_use_strong_propagation_in_disjunctive(bool value) {
  _internal_set_use_strong_propagation_in_disjunctive(value);
  SetHasBit(_impl_._has_bits_[2], 0x20000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_strong_propagation_in_disjunctive)
}
inline bool SatParameters::_internal_use_strong_propagation_in_disjunctive() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_strong_propagation_in_disjunctive_;
}
inline void SatParameters::_internal_set_use_strong_propagation_in_disjunctive(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_strong_propagation_in_disjunctive_ = value;
}
 
// optional bool use_dynamic_precedence_in_disjunctive = 263 [default = false];
inline bool SatParameters::has_use_dynamic_precedence_in_disjunctive() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000020U);
  return value;
}
inline void SatParameters::clear_use_dynamic_precedence_in_disjunctive() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dynamic_precedence_in_disjunctive_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000020U);
}
inline bool SatParameters::use_dynamic_precedence_in_disjunctive() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_dynamic_precedence_in_disjunctive)
  return _internal_use_dynamic_precedence_in_disjunctive();
}
inline void SatParameters::set_use_dynamic_precedence_in_disjunctive(bool value) {
  _internal_set_use_dynamic_precedence_in_disjunctive(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_dynamic_precedence_in_disjunctive)
}
inline bool SatParameters::_internal_use_dynamic_precedence_in_disjunctive() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_dynamic_precedence_in_disjunctive_;
}
inline void SatParameters::_internal_set_use_dynamic_precedence_in_disjunctive(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dynamic_precedence_in_disjunctive_ = value;
}
 
// optional bool use_dynamic_precedence_in_cumulative = 268 [default = false];
inline bool SatParameters::has_use_dynamic_precedence_in_cumulative() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000040U);
  return value;
}
inline void SatParameters::clear_use_dynamic_precedence_in_cumulative() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dynamic_precedence_in_cumulative_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000040U);
}
inline bool SatParameters::use_dynamic_precedence_in_cumulative() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_dynamic_precedence_in_cumulative)
  return _internal_use_dynamic_precedence_in_cumulative();
}
inline void SatParameters::set_use_dynamic_precedence_in_cumulative(bool value) {
  _internal_set_use_dynamic_precedence_in_cumulative(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_dynamic_precedence_in_cumulative)
}
inline bool SatParameters::_internal_use_dynamic_precedence_in_cumulative() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_dynamic_precedence_in_cumulative_;
}
inline void SatParameters::_internal_set_use_dynamic_precedence_in_cumulative(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dynamic_precedence_in_cumulative_ = value;
}
 
// optional bool use_overload_checker_in_cumulative = 78 [default = false];
inline bool SatParameters::has_use_overload_checker_in_cumulative() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000400U);
  return value;
}
inline void SatParameters::clear_use_overload_checker_in_cumulative() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_overload_checker_in_cumulative_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000400U);
}
inline bool SatParameters::use_overload_checker_in_cumulative() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_overload_checker_in_cumulative)
  return _internal_use_overload_checker_in_cumulative();
}
inline void SatParameters::set_use_overload_checker_in_cumulative(bool value) {
  _internal_set_use_overload_checker_in_cumulative(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_overload_checker_in_cumulative)
}
inline bool SatParameters::_internal_use_overload_checker_in_cumulative() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_overload_checker_in_cumulative_;
}
inline void SatParameters::_internal_set_use_overload_checker_in_cumulative(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_overload_checker_in_cumulative_ = value;
}
 
// optional bool use_conservative_scale_overload_checker = 286 [default = false];
inline bool SatParameters::has_use_conservative_scale_overload_checker() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00001000U);
  return value;
}
inline void SatParameters::clear_use_conservative_scale_overload_checker() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_conservative_scale_overload_checker_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00001000U);
}
inline bool SatParameters::use_conservative_scale_overload_checker() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_conservative_scale_overload_checker)
  return _internal_use_conservative_scale_overload_checker();
}
inline void SatParameters::set_use_conservative_scale_overload_checker(bool value) {
  _internal_set_use_conservative_scale_overload_checker(value);
  SetHasBit(_impl_._has_bits_[3], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_conservative_scale_overload_checker)
}
inline bool SatParameters::_internal_use_conservative_scale_overload_checker() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_conservative_scale_overload_checker_;
}
inline void SatParameters::_internal_set_use_conservative_scale_overload_checker(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_conservative_scale_overload_checker_ = value;
}
 
// optional bool use_timetable_edge_finding_in_cumulative = 79 [default = false];
inline bool SatParameters::has_use_timetable_edge_finding_in_cumulative() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000800U);
  return value;
}
inline void SatParameters::clear_use_timetable_edge_finding_in_cumulative() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_timetable_edge_finding_in_cumulative_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00000800U);
}
inline bool SatParameters::use_timetable_edge_finding_in_cumulative() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_timetable_edge_finding_in_cumulative)
  return _internal_use_timetable_edge_finding_in_cumulative();
}
inline void SatParameters::set_use_timetable_edge_finding_in_cumulative(bool value) {
  _internal_set_use_timetable_edge_finding_in_cumulative(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_timetable_edge_finding_in_cumulative)
}
inline bool SatParameters::_internal_use_timetable_edge_finding_in_cumulative() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_timetable_edge_finding_in_cumulative_;
}
inline void SatParameters::_internal_set_use_timetable_edge_finding_in_cumulative(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_timetable_edge_finding_in_cumulative_ = value;
}
 
// optional int32 max_num_intervals_for_timetable_edge_finding = 260 [default = 100];
inline bool SatParameters::has_max_num_intervals_for_timetable_edge_finding() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x01000000U);
  return value;
}
inline void SatParameters::clear_max_num_intervals_for_timetable_edge_finding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_num_intervals_for_timetable_edge_finding_ = 100;
  ClearHasBit(_impl_._has_bits_[7],
                  0x01000000U);
}
inline ::int32_t SatParameters::max_num_intervals_for_timetable_edge_finding() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_num_intervals_for_timetable_edge_finding)
  return _internal_max_num_intervals_for_timetable_edge_finding();
}
inline void SatParameters::set_max_num_intervals_for_timetable_edge_finding(::int32_t value) {
  _internal_set_max_num_intervals_for_timetable_edge_finding(value);
  SetHasBit(_impl_._has_bits_[7], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_num_intervals_for_timetable_edge_finding)
}
inline ::int32_t SatParameters::_internal_max_num_intervals_for_timetable_edge_finding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_num_intervals_for_timetable_edge_finding_;
}
inline void SatParameters::_internal_set_max_num_intervals_for_timetable_edge_finding(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_num_intervals_for_timetable_edge_finding_ = value;
}
 
// optional bool use_hard_precedences_in_cumulative = 215 [default = false];
inline bool SatParameters::has_use_hard_precedences_in_cumulative() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00400000U);
  return value;
}
inline void SatParameters::clear_use_hard_precedences_in_cumulative() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_hard_precedences_in_cumulative_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00400000U);
}
inline bool SatParameters::use_hard_precedences_in_cumulative() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_hard_precedences_in_cumulative)
  return _internal_use_hard_precedences_in_cumulative();
}
inline void SatParameters::set_use_hard_precedences_in_cumulative(bool value) {
  _internal_set_use_hard_precedences_in_cumulative(value);
  SetHasBit(_impl_._has_bits_[2], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_hard_precedences_in_cumulative)
}
inline bool SatParameters::_internal_use_hard_precedences_in_cumulative() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_hard_precedences_in_cumulative_;
}
inline void SatParameters::_internal_set_use_hard_precedences_in_cumulative(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_hard_precedences_in_cumulative_ = value;
}
 
// optional bool exploit_all_precedences = 220 [default = false];
inline bool SatParameters::has_exploit_all_precedences() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x01000000U);
  return value;
}
inline void SatParameters::clear_exploit_all_precedences() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_all_precedences_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x01000000U);
}
inline bool SatParameters::exploit_all_precedences() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_all_precedences)
  return _internal_exploit_all_precedences();
}
inline void SatParameters::set_exploit_all_precedences(bool value) {
  _internal_set_exploit_all_precedences(value);
  SetHasBit(_impl_._has_bits_[2], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_all_precedences)
}
inline bool SatParameters::_internal_exploit_all_precedences() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exploit_all_precedences_;
}
inline void SatParameters::_internal_set_exploit_all_precedences(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_all_precedences_ = value;
}
 
// optional bool use_disjunctive_constraint_in_cumulative = 80 [default = true];
inline bool SatParameters::has_use_disjunctive_constraint_in_cumulative() const {
  bool value = CheckHasBit(_impl_._has_bits_[4], 0x02000000U);
  return value;
}
inline void SatParameters::clear_use_disjunctive_constraint_in_cumulative() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_disjunctive_constraint_in_cumulative_ = true;
  ClearHasBit(_impl_._has_bits_[4],
                  0x02000000U);
}
inline bool SatParameters::use_disjunctive_constraint_in_cumulative() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_disjunctive_constraint_in_cumulative)
  return _internal_use_disjunctive_constraint_in_cumulative();
}
inline void SatParameters::set_use_disjunctive_constraint_in_cumulative(bool value) {
  _internal_set_use_disjunctive_constraint_in_cumulative(value);
  SetHasBit(_impl_._has_bits_[4], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_disjunctive_constraint_in_cumulative)
}
inline bool SatParameters::_internal_use_disjunctive_constraint_in_cumulative() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_disjunctive_constraint_in_cumulative_;
}
inline void SatParameters::_internal_set_use_disjunctive_constraint_in_cumulative(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_disjunctive_constraint_in_cumulative_ = value;
}
 
// optional int32 no_overlap_2d_boolean_relations_limit = 321 [default = 10];
inline bool SatParameters::has_no_overlap_2d_boolean_relations_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x40000000U);
  return value;
}
inline void SatParameters::clear_no_overlap_2d_boolean_relations_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.no_overlap_2d_boolean_relations_limit_ = 10;
  ClearHasBit(_impl_._has_bits_[8],
                  0x40000000U);
}
inline ::int32_t SatParameters::no_overlap_2d_boolean_relations_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.no_overlap_2d_boolean_relations_limit)
  return _internal_no_overlap_2d_boolean_relations_limit();
}
inline void SatParameters::set_no_overlap_2d_boolean_relations_limit(::int32_t value) {
  _internal_set_no_overlap_2d_boolean_relations_limit(value);
  SetHasBit(_impl_._has_bits_[8], 0x40000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.no_overlap_2d_boolean_relations_limit)
}
inline ::int32_t SatParameters::_internal_no_overlap_2d_boolean_relations_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.no_overlap_2d_boolean_relations_limit_;
}
inline void SatParameters::_internal_set_no_overlap_2d_boolean_relations_limit(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.no_overlap_2d_boolean_relations_limit_ = value;
}
 
// optional bool use_timetabling_in_no_overlap_2d = 200 [default = false];
inline bool SatParameters::has_use_timetabling_in_no_overlap_2d() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00100000U);
  return value;
}
inline void SatParameters::clear_use_timetabling_in_no_overlap_2d() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_timetabling_in_no_overlap_2d_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00100000U);
}
inline bool SatParameters::use_timetabling_in_no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_timetabling_in_no_overlap_2d)
  return _internal_use_timetabling_in_no_overlap_2d();
}
inline void SatParameters::set_use_timetabling_in_no_overlap_2d(bool value) {
  _internal_set_use_timetabling_in_no_overlap_2d(value);
  SetHasBit(_impl_._has_bits_[2], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_timetabling_in_no_overlap_2d)
}
inline bool SatParameters::_internal_use_timetabling_in_no_overlap_2d() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_timetabling_in_no_overlap_2d_;
}
inline void SatParameters::_internal_set_use_timetabling_in_no_overlap_2d(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_timetabling_in_no_overlap_2d_ = value;
}
 
// optional bool use_energetic_reasoning_in_no_overlap_2d = 213 [default = false];
inline bool SatParameters::has_use_energetic_reasoning_in_no_overlap_2d() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00200000U);
  return value;
}
inline void SatParameters::clear_use_energetic_reasoning_in_no_overlap_2d() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_energetic_reasoning_in_no_overlap_2d_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00200000U);
}
inline bool SatParameters::use_energetic_reasoning_in_no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_energetic_reasoning_in_no_overlap_2d)
  return _internal_use_energetic_reasoning_in_no_overlap_2d();
}
inline void SatParameters::set_use_energetic_reasoning_in_no_overlap_2d(bool value) {
  _internal_set_use_energetic_reasoning_in_no_overlap_2d(value);
  SetHasBit(_impl_._has_bits_[2], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_energetic_reasoning_in_no_overlap_2d)
}
inline bool SatParameters::_internal_use_energetic_reasoning_in_no_overlap_2d() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_energetic_reasoning_in_no_overlap_2d_;
}
inline void SatParameters::_internal_set_use_energetic_reasoning_in_no_overlap_2d(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_energetic_reasoning_in_no_overlap_2d_ = value;
}
 
// optional bool use_area_energetic_reasoning_in_no_overlap_2d = 271 [default = false];
inline bool SatParameters::has_use_area_energetic_reasoning_in_no_overlap_2d() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000080U);
  return value;
}
inline void SatParameters::clear_use_area_energetic_reasoning_in_no_overlap_2d() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_area_energetic_reasoning_in_no_overlap_2d_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000080U);
}
inline bool SatParameters::use_area_energetic_reasoning_in_no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_area_energetic_reasoning_in_no_overlap_2d)
  return _internal_use_area_energetic_reasoning_in_no_overlap_2d();
}
inline void SatParameters::set_use_area_energetic_reasoning_in_no_overlap_2d(bool value) {
  _internal_set_use_area_energetic_reasoning_in_no_overlap_2d(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_area_energetic_reasoning_in_no_overlap_2d)
}
inline bool SatParameters::_internal_use_area_energetic_reasoning_in_no_overlap_2d() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_area_energetic_reasoning_in_no_overlap_2d_;
}
inline void SatParameters::_internal_set_use_area_energetic_reasoning_in_no_overlap_2d(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_area_energetic_reasoning_in_no_overlap_2d_ = value;
}
 
// optional bool use_try_edge_reasoning_in_no_overlap_2d = 299 [default = false];
inline bool SatParameters::has_use_try_edge_reasoning_in_no_overlap_2d() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00040000U);
  return value;
}
inline void SatParameters::clear_use_try_edge_reasoning_in_no_overlap_2d() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_try_edge_reasoning_in_no_overlap_2d_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00040000U);
}
inline bool SatParameters::use_try_edge_reasoning_in_no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_try_edge_reasoning_in_no_overlap_2d)
  return _internal_use_try_edge_reasoning_in_no_overlap_2d();
}
inline void SatParameters::set_use_try_edge_reasoning_in_no_overlap_2d(bool value) {
  _internal_set_use_try_edge_reasoning_in_no_overlap_2d(value);
  SetHasBit(_impl_._has_bits_[3], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_try_edge_reasoning_in_no_overlap_2d)
}
inline bool SatParameters::_internal_use_try_edge_reasoning_in_no_overlap_2d() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_try_edge_reasoning_in_no_overlap_2d_;
}
inline void SatParameters::_internal_set_use_try_edge_reasoning_in_no_overlap_2d(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_try_edge_reasoning_in_no_overlap_2d_ = value;
}
 
// optional int32 max_pairs_pairwise_reasoning_in_no_overlap_2d = 276 [default = 1250];
inline bool SatParameters::has_max_pairs_pairwise_reasoning_in_no_overlap_2d() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000040U);
  return value;
}
inline void SatParameters::clear_max_pairs_pairwise_reasoning_in_no_overlap_2d() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_pairs_pairwise_reasoning_in_no_overlap_2d_ = 1250;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000040U);
}
inline ::int32_t SatParameters::max_pairs_pairwise_reasoning_in_no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_pairs_pairwise_reasoning_in_no_overlap_2d)
  return _internal_max_pairs_pairwise_reasoning_in_no_overlap_2d();
}
inline void SatParameters::set_max_pairs_pairwise_reasoning_in_no_overlap_2d(::int32_t value) {
  _internal_set_max_pairs_pairwise_reasoning_in_no_overlap_2d(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_pairs_pairwise_reasoning_in_no_overlap_2d)
}
inline ::int32_t SatParameters::_internal_max_pairs_pairwise_reasoning_in_no_overlap_2d() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_pairs_pairwise_reasoning_in_no_overlap_2d_;
}
inline void SatParameters::_internal_set_max_pairs_pairwise_reasoning_in_no_overlap_2d(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_pairs_pairwise_reasoning_in_no_overlap_2d_ = value;
}
 
// optional int32 maximum_regions_to_split_in_disconnected_no_overlap_2d = 315 [default = 0];
inline bool SatParameters::has_maximum_regions_to_split_in_disconnected_no_overlap_2d() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x08000000U);
  return value;
}
inline void SatParameters::clear_maximum_regions_to_split_in_disconnected_no_overlap_2d() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.maximum_regions_to_split_in_disconnected_no_overlap_2d_ = 0;
  ClearHasBit(_impl_._has_bits_[3],
                  0x08000000U);
}
inline ::int32_t SatParameters::maximum_regions_to_split_in_disconnected_no_overlap_2d() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.maximum_regions_to_split_in_disconnected_no_overlap_2d)
  return _internal_maximum_regions_to_split_in_disconnected_no_overlap_2d();
}
inline void SatParameters::set_maximum_regions_to_split_in_disconnected_no_overlap_2d(::int32_t value) {
  _internal_set_maximum_regions_to_split_in_disconnected_no_overlap_2d(value);
  SetHasBit(_impl_._has_bits_[3], 0x08000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.maximum_regions_to_split_in_disconnected_no_overlap_2d)
}
inline ::int32_t SatParameters::_internal_maximum_regions_to_split_in_disconnected_no_overlap_2d() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.maximum_regions_to_split_in_disconnected_no_overlap_2d_;
}
inline void SatParameters::_internal_set_maximum_regions_to_split_in_disconnected_no_overlap_2d(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.maximum_regions_to_split_in_disconnected_no_overlap_2d_ = value;
}
 
// optional bool use_linear3_for_no_overlap_2d_precedences = 323 [default = true];
inline bool SatParameters::has_use_linear3_for_no_overlap_2d_precedences() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x01000000U);
  return value;
}
inline void SatParameters::clear_use_linear3_for_no_overlap_2d_precedences() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_linear3_for_no_overlap_2d_precedences_ = true;
  ClearHasBit(_impl_._has_bits_[8],
                  0x01000000U);
}
inline bool SatParameters::use_linear3_for_no_overlap_2d_precedences() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_linear3_for_no_overlap_2d_precedences)
  return _internal_use_linear3_for_no_overlap_2d_precedences();
}
inline void SatParameters::set_use_linear3_for_no_overlap_2d_precedences(bool value) {
  _internal_set_use_linear3_for_no_overlap_2d_precedences(value);
  SetHasBit(_impl_._has_bits_[8], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_linear3_for_no_overlap_2d_precedences)
}
inline bool SatParameters::_internal_use_linear3_for_no_overlap_2d_precedences() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_linear3_for_no_overlap_2d_precedences_;
}
inline void SatParameters::_internal_set_use_linear3_for_no_overlap_2d_precedences(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_linear3_for_no_overlap_2d_precedences_ = value;
}
 
// optional bool use_dual_scheduling_heuristics = 214 [default = true];
inline bool SatParameters::has_use_dual_scheduling_heuristics() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000002U);
  return value;
}
inline void SatParameters::clear_use_dual_scheduling_heuristics() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dual_scheduling_heuristics_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000002U);
}
inline bool SatParameters::use_dual_scheduling_heuristics() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_dual_scheduling_heuristics)
  return _internal_use_dual_scheduling_heuristics();
}
inline void SatParameters::set_use_dual_scheduling_heuristics(bool value) {
  _internal_set_use_dual_scheduling_heuristics(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_dual_scheduling_heuristics)
}
inline bool SatParameters::_internal_use_dual_scheduling_heuristics() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_dual_scheduling_heuristics_;
}
inline void SatParameters::_internal_set_use_dual_scheduling_heuristics(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_dual_scheduling_heuristics_ = value;
}
 
// optional bool use_all_different_for_circuit = 311 [default = false];
inline bool SatParameters::has_use_all_different_for_circuit() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x01000000U);
  return value;
}
inline void SatParameters::clear_use_all_different_for_circuit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_all_different_for_circuit_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x01000000U);
}
inline bool SatParameters::use_all_different_for_circuit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_all_different_for_circuit)
  return _internal_use_all_different_for_circuit();
}
inline void SatParameters::set_use_all_different_for_circuit(bool value) {
  _internal_set_use_all_different_for_circuit(value);
  SetHasBit(_impl_._has_bits_[3], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_all_different_for_circuit)
}
inline bool SatParameters::_internal_use_all_different_for_circuit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_all_different_for_circuit_;
}
inline void SatParameters::_internal_set_use_all_different_for_circuit(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_all_different_for_circuit_ = value;
}
 
// optional int32 routing_cut_subset_size_for_binary_relation_bound = 312 [default = 0];
inline bool SatParameters::has_routing_cut_subset_size_for_binary_relation_bound() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00200000U);
  return value;
}
inline void SatParameters::clear_routing_cut_subset_size_for_binary_relation_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_subset_size_for_binary_relation_bound_ = 0;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00200000U);
}
inline ::int32_t SatParameters::routing_cut_subset_size_for_binary_relation_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.routing_cut_subset_size_for_binary_relation_bound)
  return _internal_routing_cut_subset_size_for_binary_relation_bound();
}
inline void SatParameters::set_routing_cut_subset_size_for_binary_relation_bound(::int32_t value) {
  _internal_set_routing_cut_subset_size_for_binary_relation_bound(value);
  SetHasBit(_impl_._has_bits_[3], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.routing_cut_subset_size_for_binary_relation_bound)
}
inline ::int32_t SatParameters::_internal_routing_cut_subset_size_for_binary_relation_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.routing_cut_subset_size_for_binary_relation_bound_;
}
inline void SatParameters::_internal_set_routing_cut_subset_size_for_binary_relation_bound(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_subset_size_for_binary_relation_bound_ = value;
}
 
// optional int32 routing_cut_subset_size_for_tight_binary_relation_bound = 313 [default = 0];
inline bool SatParameters::has_routing_cut_subset_size_for_tight_binary_relation_bound() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x04000000U);
  return value;
}
inline void SatParameters::clear_routing_cut_subset_size_for_tight_binary_relation_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_subset_size_for_tight_binary_relation_bound_ = 0;
  ClearHasBit(_impl_._has_bits_[3],
                  0x04000000U);
}
inline ::int32_t SatParameters::routing_cut_subset_size_for_tight_binary_relation_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.routing_cut_subset_size_for_tight_binary_relation_bound)
  return _internal_routing_cut_subset_size_for_tight_binary_relation_bound();
}
inline void SatParameters::set_routing_cut_subset_size_for_tight_binary_relation_bound(::int32_t value) {
  _internal_set_routing_cut_subset_size_for_tight_binary_relation_bound(value);
  SetHasBit(_impl_._has_bits_[3], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.routing_cut_subset_size_for_tight_binary_relation_bound)
}
inline ::int32_t SatParameters::_internal_routing_cut_subset_size_for_tight_binary_relation_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.routing_cut_subset_size_for_tight_binary_relation_bound_;
}
inline void SatParameters::_internal_set_routing_cut_subset_size_for_tight_binary_relation_bound(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_subset_size_for_tight_binary_relation_bound_ = value;
}
 
// optional int32 routing_cut_subset_size_for_exact_binary_relation_bound = 316 [default = 8];
inline bool SatParameters::has_routing_cut_subset_size_for_exact_binary_relation_bound() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x02000000U);
  return value;
}
inline void SatParameters::clear_routing_cut_subset_size_for_exact_binary_relation_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_subset_size_for_exact_binary_relation_bound_ = 8;
  ClearHasBit(_impl_._has_bits_[8],
                  0x02000000U);
}
inline ::int32_t SatParameters::routing_cut_subset_size_for_exact_binary_relation_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.routing_cut_subset_size_for_exact_binary_relation_bound)
  return _internal_routing_cut_subset_size_for_exact_binary_relation_bound();
}
inline void SatParameters::set_routing_cut_subset_size_for_exact_binary_relation_bound(::int32_t value) {
  _internal_set_routing_cut_subset_size_for_exact_binary_relation_bound(value);
  SetHasBit(_impl_._has_bits_[8], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.routing_cut_subset_size_for_exact_binary_relation_bound)
}
inline ::int32_t SatParameters::_internal_routing_cut_subset_size_for_exact_binary_relation_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.routing_cut_subset_size_for_exact_binary_relation_bound_;
}
inline void SatParameters::_internal_set_routing_cut_subset_size_for_exact_binary_relation_bound(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_subset_size_for_exact_binary_relation_bound_ = value;
}
 
// optional int32 routing_cut_subset_size_for_shortest_paths_bound = 318 [default = 8];
inline bool SatParameters::has_routing_cut_subset_size_for_shortest_paths_bound() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x10000000U);
  return value;
}
inline void SatParameters::clear_routing_cut_subset_size_for_shortest_paths_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_subset_size_for_shortest_paths_bound_ = 8;
  ClearHasBit(_impl_._has_bits_[8],
                  0x10000000U);
}
inline ::int32_t SatParameters::routing_cut_subset_size_for_shortest_paths_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.routing_cut_subset_size_for_shortest_paths_bound)
  return _internal_routing_cut_subset_size_for_shortest_paths_bound();
}
inline void SatParameters::set_routing_cut_subset_size_for_shortest_paths_bound(::int32_t value) {
  _internal_set_routing_cut_subset_size_for_shortest_paths_bound(value);
  SetHasBit(_impl_._has_bits_[8], 0x10000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.routing_cut_subset_size_for_shortest_paths_bound)
}
inline ::int32_t SatParameters::_internal_routing_cut_subset_size_for_shortest_paths_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.routing_cut_subset_size_for_shortest_paths_bound_;
}
inline void SatParameters::_internal_set_routing_cut_subset_size_for_shortest_paths_bound(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_subset_size_for_shortest_paths_bound_ = value;
}
 
// optional double routing_cut_dp_effort = 314 [default = 10000000];
inline bool SatParameters::has_routing_cut_dp_effort() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x04000000U);
  return value;
}
inline void SatParameters::clear_routing_cut_dp_effort() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_dp_effort_ = 10000000;
  ClearHasBit(_impl_._has_bits_[8],
                  0x04000000U);
}
inline double SatParameters::routing_cut_dp_effort() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.routing_cut_dp_effort)
  return _internal_routing_cut_dp_effort();
}
inline void SatParameters::set_routing_cut_dp_effort(double value) {
  _internal_set_routing_cut_dp_effort(value);
  SetHasBit(_impl_._has_bits_[8], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.routing_cut_dp_effort)
}
inline double SatParameters::_internal_routing_cut_dp_effort() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.routing_cut_dp_effort_;
}
inline void SatParameters::_internal_set_routing_cut_dp_effort(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_dp_effort_ = value;
}
 
// optional int32 routing_cut_max_infeasible_path_length = 317 [default = 6];
inline bool SatParameters::has_routing_cut_max_infeasible_path_length() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x08000000U);
  return value;
}
inline void SatParameters::clear_routing_cut_max_infeasible_path_length() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_max_infeasible_path_length_ = 6;
  ClearHasBit(_impl_._has_bits_[8],
                  0x08000000U);
}
inline ::int32_t SatParameters::routing_cut_max_infeasible_path_length() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.routing_cut_max_infeasible_path_length)
  return _internal_routing_cut_max_infeasible_path_length();
}
inline void SatParameters::set_routing_cut_max_infeasible_path_length(::int32_t value) {
  _internal_set_routing_cut_max_infeasible_path_length(value);
  SetHasBit(_impl_._has_bits_[8], 0x08000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.routing_cut_max_infeasible_path_length)
}
inline ::int32_t SatParameters::_internal_routing_cut_max_infeasible_path_length() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.routing_cut_max_infeasible_path_length_;
}
inline void SatParameters::_internal_set_routing_cut_max_infeasible_path_length(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.routing_cut_max_infeasible_path_length_ = value;
}
 
// optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
inline bool SatParameters::has_search_branching() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00002000U);
  return value;
}
inline void SatParameters::clear_search_branching() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.search_branching_ = 0;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00002000U);
}
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::set_search_branching(::operations_research::sat::SatParameters_SearchBranching value) {
  _internal_set_search_branching(value);
  SetHasBit(_impl_._has_bits_[1], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.search_branching)
}
inline ::operations_research::sat::SatParameters_SearchBranching SatParameters::_internal_search_branching() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_SearchBranching>(_impl_.search_branching_);
}
inline void SatParameters::_internal_set_search_branching(::operations_research::sat::SatParameters_SearchBranching value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_SearchBranching_internal_data_));
                                          _impl_.search_branching_ = value;
}
 
// optional int32 hint_conflict_limit = 153 [default = 10];
inline bool SatParameters::has_hint_conflict_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000080U);
  return value;
}
inline void SatParameters::clear_hint_conflict_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hint_conflict_limit_ = 10;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000080U);
}
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::set_hint_conflict_limit(::int32_t value) {
  _internal_set_hint_conflict_limit(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.hint_conflict_limit)
}
inline ::int32_t SatParameters::_internal_hint_conflict_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.hint_conflict_limit_;
}
inline void SatParameters::_internal_set_hint_conflict_limit(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hint_conflict_limit_ = value;
}
 
// optional bool repair_hint = 167 [default = false];
inline bool SatParameters::has_repair_hint() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000004U);
  return value;
}
inline void SatParameters::clear_repair_hint() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.repair_hint_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000004U);
}
inline bool SatParameters::repair_hint() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.repair_hint)
  return _internal_repair_hint();
}
inline void SatParameters::set_repair_hint(bool value) {
  _internal_set_repair_hint(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.repair_hint)
}
inline bool SatParameters::_internal_repair_hint() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.repair_hint_;
}
inline void SatParameters::_internal_set_repair_hint(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.repair_hint_ = value;
}
 
// optional bool fix_variables_to_their_hinted_value = 192 [default = false];
inline bool SatParameters::has_fix_variables_to_their_hinted_value() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00008000U);
  return value;
}
inline void SatParameters::clear_fix_variables_to_their_hinted_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fix_variables_to_their_hinted_value_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00008000U);
}
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::set_fix_variables_to_their_hinted_value(bool value) {
  _internal_set_fix_variables_to_their_hinted_value(value);
  SetHasBit(_impl_._has_bits_[2], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fix_variables_to_their_hinted_value)
}
inline bool SatParameters::_internal_fix_variables_to_their_hinted_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.fix_variables_to_their_hinted_value_;
}
inline void SatParameters::_internal_set_fix_variables_to_their_hinted_value(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fix_variables_to_their_hinted_value_ = value;
}
 
// optional bool use_probing_search = 176 [default = false];
inline bool SatParameters::has_use_probing_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000080U);
  return value;
}
inline void SatParameters::clear_use_probing_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_probing_search_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000080U);
}
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::set_use_probing_search(bool value) {
  _internal_set_use_probing_search(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_probing_search)
}
inline bool SatParameters::_internal_use_probing_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_probing_search_;
}
inline void SatParameters::_internal_set_use_probing_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_probing_search_ = value;
}
 
// optional bool use_extended_probing = 269 [default = true];
inline bool SatParameters::has_use_extended_probing() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x40000000U);
  return value;
}
inline void SatParameters::clear_use_extended_probing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_extended_probing_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x40000000U);
}
inline bool SatParameters::use_extended_probing() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_extended_probing)
  return _internal_use_extended_probing();
}
inline void SatParameters::set_use_extended_probing(bool value) {
  _internal_set_use_extended_probing(value);
  SetHasBit(_impl_._has_bits_[7], 0x40000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_extended_probing)
}
inline bool SatParameters::_internal_use_extended_probing() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_extended_probing_;
}
inline void SatParameters::_internal_set_use_extended_probing(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_extended_probing_ = value;
}
 
// optional int32 probing_num_combinations_limit = 272 [default = 20000];
inline bool SatParameters::has_probing_num_combinations_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000004U);
  return value;
}
inline void SatParameters::clear_probing_num_combinations_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.probing_num_combinations_limit_ = 20000;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000004U);
}
inline ::int32_t SatParameters::probing_num_combinations_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.probing_num_combinations_limit)
  return _internal_probing_num_combinations_limit();
}
inline void SatParameters::set_probing_num_combinations_limit(::int32_t value) {
  _internal_set_probing_num_combinations_limit(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.probing_num_combinations_limit)
}
inline ::int32_t SatParameters::_internal_probing_num_combinations_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.probing_num_combinations_limit_;
}
inline void SatParameters::_internal_set_probing_num_combinations_limit(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.probing_num_combinations_limit_ = value;
}
 
// optional double shaving_deterministic_time_in_probing_search = 204 [default = 0.001];
inline bool SatParameters::has_shaving_deterministic_time_in_probing_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000004U);
  return value;
}
inline void SatParameters::clear_shaving_deterministic_time_in_probing_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shaving_deterministic_time_in_probing_search_ = 0.001;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000004U);
}
inline double SatParameters::shaving_deterministic_time_in_probing_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shaving_deterministic_time_in_probing_search)
  return _internal_shaving_deterministic_time_in_probing_search();
}
inline void SatParameters::set_shaving_deterministic_time_in_probing_search(double value) {
  _internal_set_shaving_deterministic_time_in_probing_search(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shaving_deterministic_time_in_probing_search)
}
inline double SatParameters::_internal_shaving_deterministic_time_in_probing_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shaving_deterministic_time_in_probing_search_;
}
inline void SatParameters::_internal_set_shaving_deterministic_time_in_probing_search(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shaving_deterministic_time_in_probing_search_ = value;
}
 
// optional double shaving_search_deterministic_time = 205 [default = 0.1];
inline bool SatParameters::has_shaving_search_deterministic_time() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000008U);
  return value;
}
inline void SatParameters::clear_shaving_search_deterministic_time() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shaving_search_deterministic_time_ = 0.1;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000008U);
}
inline double SatParameters::shaving_search_deterministic_time() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shaving_search_deterministic_time)
  return _internal_shaving_search_deterministic_time();
}
inline void SatParameters::set_shaving_search_deterministic_time(double value) {
  _internal_set_shaving_search_deterministic_time(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shaving_search_deterministic_time)
}
inline double SatParameters::_internal_shaving_search_deterministic_time() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shaving_search_deterministic_time_;
}
inline void SatParameters::_internal_set_shaving_search_deterministic_time(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shaving_search_deterministic_time_ = value;
}
 
// optional int64 shaving_search_threshold = 290 [default = 64];
inline bool SatParameters::has_shaving_search_threshold() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00004000U);
  return value;
}
inline void SatParameters::clear_shaving_search_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shaving_search_threshold_ = ::int64_t{64};
  ClearHasBit(_impl_._has_bits_[8],
                  0x00004000U);
}
inline ::int64_t SatParameters::shaving_search_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shaving_search_threshold)
  return _internal_shaving_search_threshold();
}
inline void SatParameters::set_shaving_search_threshold(::int64_t value) {
  _internal_set_shaving_search_threshold(value);
  SetHasBit(_impl_._has_bits_[8], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shaving_search_threshold)
}
inline ::int64_t SatParameters::_internal_shaving_search_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shaving_search_threshold_;
}
inline void SatParameters::_internal_set_shaving_search_threshold(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shaving_search_threshold_ = value;
}
 
// optional bool use_objective_lb_search = 228 [default = false];
inline bool SatParameters::has_use_objective_lb_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x10000000U);
  return value;
}
inline void SatParameters::clear_use_objective_lb_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_objective_lb_search_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x10000000U);
}
inline bool SatParameters::use_objective_lb_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_objective_lb_search)
  return _internal_use_objective_lb_search();
}
inline void SatParameters::set_use_objective_lb_search(bool value) {
  _internal_set_use_objective_lb_search(value);
  SetHasBit(_impl_._has_bits_[2], 0x10000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_objective_lb_search)
}
inline bool SatParameters::_internal_use_objective_lb_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_objective_lb_search_;
}
inline void SatParameters::_internal_set_use_objective_lb_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_objective_lb_search_ = value;
}
 
// optional bool use_objective_shaving_search = 253 [default = false];
inline bool SatParameters::has_use_objective_shaving_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000008U);
  return value;
}
inline void SatParameters::clear_use_objective_shaving_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_objective_shaving_search_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000008U);
}
inline bool SatParameters::use_objective_shaving_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_objective_shaving_search)
  return _internal_use_objective_shaving_search();
}
inline void SatParameters::set_use_objective_shaving_search(bool value) {
  _internal_set_use_objective_shaving_search(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_objective_shaving_search)
}
inline bool SatParameters::_internal_use_objective_shaving_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_objective_shaving_search_;
}
inline void SatParameters::_internal_set_use_objective_shaving_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_objective_shaving_search_ = value;
}
 
// optional int32 variables_shaving_level = 289 [default = -1];
inline bool SatParameters::has_variables_shaving_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000200U);
  return value;
}
inline void SatParameters::clear_variables_shaving_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.variables_shaving_level_ = -1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000200U);
}
inline ::int32_t SatParameters::variables_shaving_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.variables_shaving_level)
  return _internal_variables_shaving_level();
}
inline void SatParameters::set_variables_shaving_level(::int32_t value) {
  _internal_set_variables_shaving_level(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.variables_shaving_level)
}
inline ::int32_t SatParameters::_internal_variables_shaving_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.variables_shaving_level_;
}
inline void SatParameters::_internal_set_variables_shaving_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.variables_shaving_level_ = value;
}
 
// optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
inline bool SatParameters::has_pseudo_cost_reliability_threshold() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00800000U);
  return value;
}
inline void SatParameters::clear_pseudo_cost_reliability_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pseudo_cost_reliability_threshold_ = ::int64_t{100};
  ClearHasBit(_impl_._has_bits_[5],
                  0x00800000U);
}
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::set_pseudo_cost_reliability_threshold(::int64_t value) {
  _internal_set_pseudo_cost_reliability_threshold(value);
  SetHasBit(_impl_._has_bits_[5], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pseudo_cost_reliability_threshold)
}
inline ::int64_t SatParameters::_internal_pseudo_cost_reliability_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pseudo_cost_reliability_threshold_;
}
inline void SatParameters::_internal_set_pseudo_cost_reliability_threshold(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pseudo_cost_reliability_threshold_ = value;
}
 
// optional bool optimize_with_core = 83 [default = false];
inline bool SatParameters::has_optimize_with_core() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00001000U);
  return value;
}
inline void SatParameters::clear_optimize_with_core() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimize_with_core_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00001000U);
}
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::set_optimize_with_core(bool value) {
  _internal_set_optimize_with_core(value);
  SetHasBit(_impl_._has_bits_[1], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_core)
}
inline bool SatParameters::_internal_optimize_with_core() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.optimize_with_core_;
}
inline void SatParameters::_internal_set_optimize_with_core(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimize_with_core_ = value;
}
 
// optional bool optimize_with_lb_tree_search = 188 [default = false];
inline bool SatParameters::has_optimize_with_lb_tree_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00002000U);
  return value;
}
inline void SatParameters::clear_optimize_with_lb_tree_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimize_with_lb_tree_search_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00002000U);
}
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::set_optimize_with_lb_tree_search(bool value) {
  _internal_set_optimize_with_lb_tree_search(value);
  SetHasBit(_impl_._has_bits_[2], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_lb_tree_search)
}
inline bool SatParameters::_internal_optimize_with_lb_tree_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.optimize_with_lb_tree_search_;
}
inline void SatParameters::_internal_set_optimize_with_lb_tree_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimize_with_lb_tree_search_ = value;
}
 
// optional bool save_lp_basis_in_lb_tree_search = 284 [default = false];
inline bool SatParameters::has_save_lp_basis_in_lb_tree_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000800U);
  return value;
}
inline void SatParameters::clear_save_lp_basis_in_lb_tree_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.save_lp_basis_in_lb_tree_search_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000800U);
}
inline bool SatParameters::save_lp_basis_in_lb_tree_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.save_lp_basis_in_lb_tree_search)
  return _internal_save_lp_basis_in_lb_tree_search();
}
inline void SatParameters::set_save_lp_basis_in_lb_tree_search(bool value) {
  _internal_set_save_lp_basis_in_lb_tree_search(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.save_lp_basis_in_lb_tree_search)
}
inline bool SatParameters::_internal_save_lp_basis_in_lb_tree_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.save_lp_basis_in_lb_tree_search_;
}
inline void SatParameters::_internal_set_save_lp_basis_in_lb_tree_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.save_lp_basis_in_lb_tree_search_ = value;
}
 
// optional int32 binary_search_num_conflicts = 99 [default = -1];
inline bool SatParameters::has_binary_search_num_conflicts() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000200U);
  return value;
}
inline void SatParameters::clear_binary_search_num_conflicts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.binary_search_num_conflicts_ = -1;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000200U);
}
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::set_binary_search_num_conflicts(::int32_t value) {
  _internal_set_binary_search_num_conflicts(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.binary_search_num_conflicts)
}
inline ::int32_t SatParameters::_internal_binary_search_num_conflicts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.binary_search_num_conflicts_;
}
inline void SatParameters::_internal_set_binary_search_num_conflicts(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.binary_search_num_conflicts_ = value;
}
 
// optional bool optimize_with_max_hs = 85 [default = false];
inline bool SatParameters::has_optimize_with_max_hs() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00004000U);
  return value;
}
inline void SatParameters::clear_optimize_with_max_hs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimize_with_max_hs_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00004000U);
}
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::set_optimize_with_max_hs(bool value) {
  _internal_set_optimize_with_max_hs(value);
  SetHasBit(_impl_._has_bits_[1], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_max_hs)
}
inline bool SatParameters::_internal_optimize_with_max_hs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.optimize_with_max_hs_;
}
inline void SatParameters::_internal_set_optimize_with_max_hs(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.optimize_with_max_hs_ = value;
}
 
// optional bool use_feasibility_jump = 265 [default = true];
inline bool SatParameters::has_use_feasibility_jump() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x20000000U);
  return value;
}
inline void SatParameters::clear_use_feasibility_jump() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_feasibility_jump_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x20000000U);
}
inline bool SatParameters::use_feasibility_jump() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_feasibility_jump)
  return _internal_use_feasibility_jump();
}
inline void SatParameters::set_use_feasibility_jump(bool value) {
  _internal_set_use_feasibility_jump(value);
  SetHasBit(_impl_._has_bits_[7], 0x20000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_feasibility_jump)
}
inline bool SatParameters::_internal_use_feasibility_jump() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_feasibility_jump_;
}
inline void SatParameters::_internal_set_use_feasibility_jump(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_feasibility_jump_ = value;
}
 
// optional bool use_ls_only = 240 [default = false];
inline bool SatParameters::has_use_ls_only() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x80000000U);
  return value;
}
inline void SatParameters::clear_use_ls_only() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_ls_only_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x80000000U);
}
inline bool SatParameters::use_ls_only() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_ls_only)
  return _internal_use_ls_only();
}
inline void SatParameters::set_use_ls_only(bool value) {
  _internal_set_use_ls_only(value);
  SetHasBit(_impl_._has_bits_[2], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_ls_only)
}
inline bool SatParameters::_internal_use_ls_only() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_ls_only_;
}
inline void SatParameters::_internal_set_use_ls_only(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_ls_only_ = value;
}
 
// optional double feasibility_jump_decay = 242 [default = 0.95];
inline bool SatParameters::has_feasibility_jump_decay() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00010000U);
  return value;
}
inline void SatParameters::clear_feasibility_jump_decay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_decay_ = 0.95;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00010000U);
}
inline double SatParameters::feasibility_jump_decay() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.feasibility_jump_decay)
  return _internal_feasibility_jump_decay();
}
inline void SatParameters::set_feasibility_jump_decay(double value) {
  _internal_set_feasibility_jump_decay(value);
  SetHasBit(_impl_._has_bits_[7], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.feasibility_jump_decay)
}
inline double SatParameters::_internal_feasibility_jump_decay() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.feasibility_jump_decay_;
}
inline void SatParameters::_internal_set_feasibility_jump_decay(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_decay_ = value;
}
 
// optional int32 feasibility_jump_linearization_level = 257 [default = 2];
inline bool SatParameters::has_feasibility_jump_linearization_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00200000U);
  return value;
}
inline void SatParameters::clear_feasibility_jump_linearization_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_linearization_level_ = 2;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00200000U);
}
inline ::int32_t SatParameters::feasibility_jump_linearization_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.feasibility_jump_linearization_level)
  return _internal_feasibility_jump_linearization_level();
}
inline void SatParameters::set_feasibility_jump_linearization_level(::int32_t value) {
  _internal_set_feasibility_jump_linearization_level(value);
  SetHasBit(_impl_._has_bits_[7], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.feasibility_jump_linearization_level)
}
inline ::int32_t SatParameters::_internal_feasibility_jump_linearization_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.feasibility_jump_linearization_level_;
}
inline void SatParameters::_internal_set_feasibility_jump_linearization_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_linearization_level_ = value;
}
 
// optional int32 feasibility_jump_restart_factor = 258 [default = 1];
inline bool SatParameters::has_feasibility_jump_restart_factor() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00400000U);
  return value;
}
inline void SatParameters::clear_feasibility_jump_restart_factor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_restart_factor_ = 1;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00400000U);
}
inline ::int32_t SatParameters::feasibility_jump_restart_factor() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.feasibility_jump_restart_factor)
  return _internal_feasibility_jump_restart_factor();
}
inline void SatParameters::set_feasibility_jump_restart_factor(::int32_t value) {
  _internal_set_feasibility_jump_restart_factor(value);
  SetHasBit(_impl_._has_bits_[7], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.feasibility_jump_restart_factor)
}
inline ::int32_t SatParameters::_internal_feasibility_jump_restart_factor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.feasibility_jump_restart_factor_;
}
inline void SatParameters::_internal_set_feasibility_jump_restart_factor(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_restart_factor_ = value;
}
 
// optional double feasibility_jump_batch_dtime = 292 [default = 0.1];
inline bool SatParameters::has_feasibility_jump_batch_dtime() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00008000U);
  return value;
}
inline void SatParameters::clear_feasibility_jump_batch_dtime() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_batch_dtime_ = 0.1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00008000U);
}
inline double SatParameters::feasibility_jump_batch_dtime() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.feasibility_jump_batch_dtime)
  return _internal_feasibility_jump_batch_dtime();
}
inline void SatParameters::set_feasibility_jump_batch_dtime(double value) {
  _internal_set_feasibility_jump_batch_dtime(value);
  SetHasBit(_impl_._has_bits_[8], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.feasibility_jump_batch_dtime)
}
inline double SatParameters::_internal_feasibility_jump_batch_dtime() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.feasibility_jump_batch_dtime_;
}
inline void SatParameters::_internal_set_feasibility_jump_batch_dtime(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_batch_dtime_ = value;
}
 
// optional double feasibility_jump_var_randomization_probability = 247 [default = 0.05];
inline bool SatParameters::has_feasibility_jump_var_randomization_probability() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00020000U);
  return value;
}
inline void SatParameters::clear_feasibility_jump_var_randomization_probability() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_var_randomization_probability_ = 0.05;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00020000U);
}
inline double SatParameters::feasibility_jump_var_randomization_probability() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.feasibility_jump_var_randomization_probability)
  return _internal_feasibility_jump_var_randomization_probability();
}
inline void SatParameters::set_feasibility_jump_var_randomization_probability(double value) {
  _internal_set_feasibility_jump_var_randomization_probability(value);
  SetHasBit(_impl_._has_bits_[7], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.feasibility_jump_var_randomization_probability)
}
inline double SatParameters::_internal_feasibility_jump_var_randomization_probability() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.feasibility_jump_var_randomization_probability_;
}
inline void SatParameters::_internal_set_feasibility_jump_var_randomization_probability(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_var_randomization_probability_ = value;
}
 
// optional double feasibility_jump_var_perburbation_range_ratio = 248 [default = 0.2];
inline bool SatParameters::has_feasibility_jump_var_perburbation_range_ratio() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00040000U);
  return value;
}
inline void SatParameters::clear_feasibility_jump_var_perburbation_range_ratio() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_var_perburbation_range_ratio_ = 0.2;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00040000U);
}
inline double SatParameters::feasibility_jump_var_perburbation_range_ratio() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.feasibility_jump_var_perburbation_range_ratio)
  return _internal_feasibility_jump_var_perburbation_range_ratio();
}
inline void SatParameters::set_feasibility_jump_var_perburbation_range_ratio(double value) {
  _internal_set_feasibility_jump_var_perburbation_range_ratio(value);
  SetHasBit(_impl_._has_bits_[7], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.feasibility_jump_var_perburbation_range_ratio)
}
inline double SatParameters::_internal_feasibility_jump_var_perburbation_range_ratio() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.feasibility_jump_var_perburbation_range_ratio_;
}
inline void SatParameters::_internal_set_feasibility_jump_var_perburbation_range_ratio(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_var_perburbation_range_ratio_ = value;
}
 
// optional bool feasibility_jump_enable_restarts = 250 [default = true];
inline bool SatParameters::has_feasibility_jump_enable_restarts() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00004000U);
  return value;
}
inline void SatParameters::clear_feasibility_jump_enable_restarts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_enable_restarts_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00004000U);
}
inline bool SatParameters::feasibility_jump_enable_restarts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.feasibility_jump_enable_restarts)
  return _internal_feasibility_jump_enable_restarts();
}
inline void SatParameters::set_feasibility_jump_enable_restarts(bool value) {
  _internal_set_feasibility_jump_enable_restarts(value);
  SetHasBit(_impl_._has_bits_[7], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.feasibility_jump_enable_restarts)
}
inline bool SatParameters::_internal_feasibility_jump_enable_restarts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.feasibility_jump_enable_restarts_;
}
inline void SatParameters::_internal_set_feasibility_jump_enable_restarts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_enable_restarts_ = value;
}
 
// optional int32 feasibility_jump_max_expanded_constraint_size = 264 [default = 500];
inline bool SatParameters::has_feasibility_jump_max_expanded_constraint_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x08000000U);
  return value;
}
inline void SatParameters::clear_feasibility_jump_max_expanded_constraint_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_max_expanded_constraint_size_ = 500;
  ClearHasBit(_impl_._has_bits_[7],
                  0x08000000U);
}
inline ::int32_t SatParameters::feasibility_jump_max_expanded_constraint_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.feasibility_jump_max_expanded_constraint_size)
  return _internal_feasibility_jump_max_expanded_constraint_size();
}
inline void SatParameters::set_feasibility_jump_max_expanded_constraint_size(::int32_t value) {
  _internal_set_feasibility_jump_max_expanded_constraint_size(value);
  SetHasBit(_impl_._has_bits_[7], 0x08000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.feasibility_jump_max_expanded_constraint_size)
}
inline ::int32_t SatParameters::_internal_feasibility_jump_max_expanded_constraint_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.feasibility_jump_max_expanded_constraint_size_;
}
inline void SatParameters::_internal_set_feasibility_jump_max_expanded_constraint_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_jump_max_expanded_constraint_size_ = value;
}
 
// optional int32 num_violation_ls = 244 [default = 0];
inline bool SatParameters::has_num_violation_ls() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000002U);
  return value;
}
inline void SatParameters::clear_num_violation_ls() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_violation_ls_ = 0;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000002U);
}
inline ::int32_t SatParameters::num_violation_ls() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_violation_ls)
  return _internal_num_violation_ls();
}
inline void SatParameters::set_num_violation_ls(::int32_t value) {
  _internal_set_num_violation_ls(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_violation_ls)
}
inline ::int32_t SatParameters::_internal_num_violation_ls() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_violation_ls_;
}
inline void SatParameters::_internal_set_num_violation_ls(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_violation_ls_ = value;
}
 
// optional int32 violation_ls_perturbation_period = 249 [default = 100];
inline bool SatParameters::has_violation_ls_perturbation_period() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00080000U);
  return value;
}
inline void SatParameters::clear_violation_ls_perturbation_period() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.violation_ls_perturbation_period_ = 100;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00080000U);
}
inline ::int32_t SatParameters::violation_ls_perturbation_period() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.violation_ls_perturbation_period)
  return _internal_violation_ls_perturbation_period();
}
inline void SatParameters::set_violation_ls_perturbation_period(::int32_t value) {
  _internal_set_violation_ls_perturbation_period(value);
  SetHasBit(_impl_._has_bits_[7], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.violation_ls_perturbation_period)
}
inline ::int32_t SatParameters::_internal_violation_ls_perturbation_period() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.violation_ls_perturbation_period_;
}
inline void SatParameters::_internal_set_violation_ls_perturbation_period(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.violation_ls_perturbation_period_ = value;
}
 
// optional double violation_ls_compound_move_probability = 259 [default = 0.5];
inline bool SatParameters::has_violation_ls_compound_move_probability() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00800000U);
  return value;
}
inline void SatParameters::clear_violation_ls_compound_move_probability() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.violation_ls_compound_move_probability_ = 0.5;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00800000U);
}
inline double SatParameters::violation_ls_compound_move_probability() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.violation_ls_compound_move_probability)
  return _internal_violation_ls_compound_move_probability();
}
inline void SatParameters::set_violation_ls_compound_move_probability(double value) {
  _internal_set_violation_ls_compound_move_probability(value);
  SetHasBit(_impl_._has_bits_[7], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.violation_ls_compound_move_probability)
}
inline double SatParameters::_internal_violation_ls_compound_move_probability() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.violation_ls_compound_move_probability_;
}
inline void SatParameters::_internal_set_violation_ls_compound_move_probability(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.violation_ls_compound_move_probability_ = value;
}
 
// optional int32 shared_tree_num_workers = 235 [default = -1];
inline bool SatParameters::has_shared_tree_num_workers() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000400U);
  return value;
}
inline void SatParameters::clear_shared_tree_num_workers() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_num_workers_ = -1;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000400U);
}
inline ::int32_t SatParameters::shared_tree_num_workers() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_num_workers)
  return _internal_shared_tree_num_workers();
}
inline void SatParameters::set_shared_tree_num_workers(::int32_t value) {
  _internal_set_shared_tree_num_workers(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_num_workers)
}
inline ::int32_t SatParameters::_internal_shared_tree_num_workers() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shared_tree_num_workers_;
}
inline void SatParameters::_internal_set_shared_tree_num_workers(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_num_workers_ = value;
}
 
// optional bool use_shared_tree_search = 236 [default = false];
inline bool SatParameters::has_use_shared_tree_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x40000000U);
  return value;
}
inline void SatParameters::clear_use_shared_tree_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_shared_tree_search_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x40000000U);
}
inline bool SatParameters::use_shared_tree_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_shared_tree_search)
  return _internal_use_shared_tree_search();
}
inline void SatParameters::set_use_shared_tree_search(bool value) {
  _internal_set_use_shared_tree_search(value);
  SetHasBit(_impl_._has_bits_[2], 0x40000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_shared_tree_search)
}
inline bool SatParameters::_internal_use_shared_tree_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_shared_tree_search_;
}
inline void SatParameters::_internal_set_use_shared_tree_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_shared_tree_search_ = value;
}
 
// optional int32 shared_tree_worker_min_restarts_per_subtree = 282 [default = 1];
inline bool SatParameters::has_shared_tree_worker_min_restarts_per_subtree() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000080U);
  return value;
}
inline void SatParameters::clear_shared_tree_worker_min_restarts_per_subtree() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_worker_min_restarts_per_subtree_ = 1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000080U);
}
inline ::int32_t SatParameters::shared_tree_worker_min_restarts_per_subtree() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_worker_min_restarts_per_subtree)
  return _internal_shared_tree_worker_min_restarts_per_subtree();
}
inline void SatParameters::set_shared_tree_worker_min_restarts_per_subtree(::int32_t value) {
  _internal_set_shared_tree_worker_min_restarts_per_subtree(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_worker_min_restarts_per_subtree)
}
inline ::int32_t SatParameters::_internal_shared_tree_worker_min_restarts_per_subtree() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shared_tree_worker_min_restarts_per_subtree_;
}
inline void SatParameters::_internal_set_shared_tree_worker_min_restarts_per_subtree(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_worker_min_restarts_per_subtree_ = value;
}
 
// optional bool shared_tree_worker_enable_trail_sharing = 295 [default = true];
inline bool SatParameters::has_shared_tree_worker_enable_trail_sharing() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00001000U);
  return value;
}
inline void SatParameters::clear_shared_tree_worker_enable_trail_sharing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_worker_enable_trail_sharing_ = true;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00001000U);
}
inline bool SatParameters::shared_tree_worker_enable_trail_sharing() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_worker_enable_trail_sharing)
  return _internal_shared_tree_worker_enable_trail_sharing();
}
inline void SatParameters::set_shared_tree_worker_enable_trail_sharing(bool value) {
  _internal_set_shared_tree_worker_enable_trail_sharing(value);
  SetHasBit(_impl_._has_bits_[8], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_worker_enable_trail_sharing)
}
inline bool SatParameters::_internal_shared_tree_worker_enable_trail_sharing() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shared_tree_worker_enable_trail_sharing_;
}
inline void SatParameters::_internal_set_shared_tree_worker_enable_trail_sharing(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_worker_enable_trail_sharing_ = value;
}
 
// optional bool shared_tree_worker_enable_phase_sharing = 304 [default = true];
inline bool SatParameters::has_shared_tree_worker_enable_phase_sharing() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00400000U);
  return value;
}
inline void SatParameters::clear_shared_tree_worker_enable_phase_sharing() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_worker_enable_phase_sharing_ = true;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00400000U);
}
inline bool SatParameters::shared_tree_worker_enable_phase_sharing() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_worker_enable_phase_sharing)
  return _internal_shared_tree_worker_enable_phase_sharing();
}
inline void SatParameters::set_shared_tree_worker_enable_phase_sharing(bool value) {
  _internal_set_shared_tree_worker_enable_phase_sharing(value);
  SetHasBit(_impl_._has_bits_[8], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_worker_enable_phase_sharing)
}
inline bool SatParameters::_internal_shared_tree_worker_enable_phase_sharing() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shared_tree_worker_enable_phase_sharing_;
}
inline void SatParameters::_internal_set_shared_tree_worker_enable_phase_sharing(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_worker_enable_phase_sharing_ = value;
}
 
// optional double shared_tree_open_leaves_per_worker = 281 [default = 2];
inline bool SatParameters::has_shared_tree_open_leaves_per_worker() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000100U);
  return value;
}
inline void SatParameters::clear_shared_tree_open_leaves_per_worker() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_open_leaves_per_worker_ = 2;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000100U);
}
inline double SatParameters::shared_tree_open_leaves_per_worker() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_open_leaves_per_worker)
  return _internal_shared_tree_open_leaves_per_worker();
}
inline void SatParameters::set_shared_tree_open_leaves_per_worker(double value) {
  _internal_set_shared_tree_open_leaves_per_worker(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_open_leaves_per_worker)
}
inline double SatParameters::_internal_shared_tree_open_leaves_per_worker() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shared_tree_open_leaves_per_worker_;
}
inline void SatParameters::_internal_set_shared_tree_open_leaves_per_worker(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_open_leaves_per_worker_ = value;
}
 
// optional int32 shared_tree_max_nodes_per_worker = 238 [default = 10000];
inline bool SatParameters::has_shared_tree_max_nodes_per_worker() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00008000U);
  return value;
}
inline void SatParameters::clear_shared_tree_max_nodes_per_worker() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_max_nodes_per_worker_ = 10000;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00008000U);
}
inline ::int32_t SatParameters::shared_tree_max_nodes_per_worker() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_max_nodes_per_worker)
  return _internal_shared_tree_max_nodes_per_worker();
}
inline void SatParameters::set_shared_tree_max_nodes_per_worker(::int32_t value) {
  _internal_set_shared_tree_max_nodes_per_worker(value);
  SetHasBit(_impl_._has_bits_[7], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_max_nodes_per_worker)
}
inline ::int32_t SatParameters::_internal_shared_tree_max_nodes_per_worker() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shared_tree_max_nodes_per_worker_;
}
inline void SatParameters::_internal_set_shared_tree_max_nodes_per_worker(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_max_nodes_per_worker_ = value;
}
 
// optional .operations_research.sat.SatParameters.SharedTreeSplitStrategy shared_tree_split_strategy = 239 [default = SPLIT_STRATEGY_AUTO];
inline bool SatParameters::has_shared_tree_split_strategy() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000001U);
  return value;
}
inline void SatParameters::clear_shared_tree_split_strategy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_split_strategy_ = 0;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000001U);
}
inline ::operations_research::sat::SatParameters_SharedTreeSplitStrategy SatParameters::shared_tree_split_strategy() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_split_strategy)
  return _internal_shared_tree_split_strategy();
}
inline void SatParameters::set_shared_tree_split_strategy(::operations_research::sat::SatParameters_SharedTreeSplitStrategy value) {
  _internal_set_shared_tree_split_strategy(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_split_strategy)
}
inline ::operations_research::sat::SatParameters_SharedTreeSplitStrategy SatParameters::_internal_shared_tree_split_strategy() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_SharedTreeSplitStrategy>(_impl_.shared_tree_split_strategy_);
}
inline void SatParameters::_internal_set_shared_tree_split_strategy(::operations_research::sat::SatParameters_SharedTreeSplitStrategy value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_SharedTreeSplitStrategy_internal_data_));
                                          _impl_.shared_tree_split_strategy_ = value;
}
 
// optional int32 shared_tree_balance_tolerance = 305 [default = 1];
inline bool SatParameters::has_shared_tree_balance_tolerance() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00020000U);
  return value;
}
inline void SatParameters::clear_shared_tree_balance_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_balance_tolerance_ = 1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00020000U);
}
inline ::int32_t SatParameters::shared_tree_balance_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_balance_tolerance)
  return _internal_shared_tree_balance_tolerance();
}
inline void SatParameters::set_shared_tree_balance_tolerance(::int32_t value) {
  _internal_set_shared_tree_balance_tolerance(value);
  SetHasBit(_impl_._has_bits_[8], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_balance_tolerance)
}
inline ::int32_t SatParameters::_internal_shared_tree_balance_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shared_tree_balance_tolerance_;
}
inline void SatParameters::_internal_set_shared_tree_balance_tolerance(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_balance_tolerance_ = value;
}
 
// optional double shared_tree_split_min_dtime = 328 [default = 0.1];
inline bool SatParameters::has_shared_tree_split_min_dtime() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000004U);
  return value;
}
inline void SatParameters::clear_shared_tree_split_min_dtime() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_split_min_dtime_ = 0.1;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000004U);
}
inline double SatParameters::shared_tree_split_min_dtime() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.shared_tree_split_min_dtime)
  return _internal_shared_tree_split_min_dtime();
}
inline void SatParameters::set_shared_tree_split_min_dtime(double value) {
  _internal_set_shared_tree_split_min_dtime(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.shared_tree_split_min_dtime)
}
inline double SatParameters::_internal_shared_tree_split_min_dtime() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shared_tree_split_min_dtime_;
}
inline void SatParameters::_internal_set_shared_tree_split_min_dtime(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shared_tree_split_min_dtime_ = value;
}
 
// optional bool enumerate_all_solutions = 87 [default = false];
inline bool SatParameters::has_enumerate_all_solutions() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00008000U);
  return value;
}
inline void SatParameters::clear_enumerate_all_solutions() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enumerate_all_solutions_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00008000U);
}
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::set_enumerate_all_solutions(bool value) {
  _internal_set_enumerate_all_solutions(value);
  SetHasBit(_impl_._has_bits_[1], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.enumerate_all_solutions)
}
inline bool SatParameters::_internal_enumerate_all_solutions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enumerate_all_solutions_;
}
inline void SatParameters::_internal_set_enumerate_all_solutions(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enumerate_all_solutions_ = value;
}
 
// optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
inline bool SatParameters::has_keep_all_feasible_solutions_in_presolve() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000010U);
  return value;
}
inline void SatParameters::clear_keep_all_feasible_solutions_in_presolve() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.keep_all_feasible_solutions_in_presolve_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000010U);
}
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::set_keep_all_feasible_solutions_in_presolve(bool value) {
  _internal_set_keep_all_feasible_solutions_in_presolve(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.keep_all_feasible_solutions_in_presolve)
}
inline bool SatParameters::_internal_keep_all_feasible_solutions_in_presolve() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.keep_all_feasible_solutions_in_presolve_;
}
inline void SatParameters::_internal_set_keep_all_feasible_solutions_in_presolve(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.keep_all_feasible_solutions_in_presolve_ = value;
}
 
// optional bool fill_tightened_domains_in_response = 132 [default = false];
inline bool SatParameters::has_fill_tightened_domains_in_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x02000000U);
  return value;
}
inline void SatParameters::clear_fill_tightened_domains_in_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fill_tightened_domains_in_response_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x02000000U);
}
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::set_fill_tightened_domains_in_response(bool value) {
  _internal_set_fill_tightened_domains_in_response(value);
  SetHasBit(_impl_._has_bits_[1], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fill_tightened_domains_in_response)
}
inline bool SatParameters::_internal_fill_tightened_domains_in_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.fill_tightened_domains_in_response_;
}
inline void SatParameters::_internal_set_fill_tightened_domains_in_response(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fill_tightened_domains_in_response_ = value;
}
 
// optional bool fill_additional_solutions_in_response = 194 [default = false];
inline bool SatParameters::has_fill_additional_solutions_in_response() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00010000U);
  return value;
}
inline void SatParameters::clear_fill_additional_solutions_in_response() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fill_additional_solutions_in_response_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00010000U);
}
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::set_fill_additional_solutions_in_response(bool value) {
  _internal_set_fill_additional_solutions_in_response(value);
  SetHasBit(_impl_._has_bits_[2], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fill_additional_solutions_in_response)
}
inline bool SatParameters::_internal_fill_additional_solutions_in_response() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.fill_additional_solutions_in_response_;
}
inline void SatParameters::_internal_set_fill_additional_solutions_in_response(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fill_additional_solutions_in_response_ = value;
}
 
// optional bool instantiate_all_variables = 106 [default = true];
inline bool SatParameters::has_instantiate_all_variables() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000100U);
  return value;
}
inline void SatParameters::clear_instantiate_all_variables() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.instantiate_all_variables_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000100U);
}
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::set_instantiate_all_variables(bool value) {
  _internal_set_instantiate_all_variables(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.instantiate_all_variables)
}
inline bool SatParameters::_internal_instantiate_all_variables() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.instantiate_all_variables_;
}
inline void SatParameters::_internal_set_instantiate_all_variables(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.instantiate_all_variables_ = value;
}
 
// optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
inline bool SatParameters::has_auto_detect_greater_than_at_least_one_of() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000080U);
  return value;
}
inline void SatParameters::clear_auto_detect_greater_than_at_least_one_of() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.auto_detect_greater_than_at_least_one_of_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000080U);
}
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::set_auto_detect_greater_than_at_least_one_of(bool value) {
  _internal_set_auto_detect_greater_than_at_least_one_of(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.auto_detect_greater_than_at_least_one_of)
}
inline bool SatParameters::_internal_auto_detect_greater_than_at_least_one_of() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.auto_detect_greater_than_at_least_one_of_;
}
inline void SatParameters::_internal_set_auto_detect_greater_than_at_least_one_of(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.auto_detect_greater_than_at_least_one_of_ = value;
}
 
// optional bool stop_after_first_solution = 98 [default = false];
inline bool SatParameters::has_stop_after_first_solution() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00020000U);
  return value;
}
inline void SatParameters::clear_stop_after_first_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stop_after_first_solution_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00020000U);
}
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::set_stop_after_first_solution(bool value) {
  _internal_set_stop_after_first_solution(value);
  SetHasBit(_impl_._has_bits_[1], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_first_solution)
}
inline bool SatParameters::_internal_stop_after_first_solution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.stop_after_first_solution_;
}
inline void SatParameters::_internal_set_stop_after_first_solution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stop_after_first_solution_ = value;
}
 
// optional bool stop_after_presolve = 149 [default = false];
inline bool SatParameters::has_stop_after_presolve() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x80000000U);
  return value;
}
inline void SatParameters::clear_stop_after_presolve() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stop_after_presolve_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x80000000U);
}
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::set_stop_after_presolve(bool value) {
  _internal_set_stop_after_presolve(value);
  SetHasBit(_impl_._has_bits_[1], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_presolve)
}
inline bool SatParameters::_internal_stop_after_presolve() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.stop_after_presolve_;
}
inline void SatParameters::_internal_set_stop_after_presolve(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stop_after_presolve_ = value;
}
 
// optional bool stop_after_root_propagation = 252 [default = false];
inline bool SatParameters::has_stop_after_root_propagation() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000004U);
  return value;
}
inline void SatParameters::clear_stop_after_root_propagation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stop_after_root_propagation_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000004U);
}
inline bool SatParameters::stop_after_root_propagation() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.stop_after_root_propagation)
  return _internal_stop_after_root_propagation();
}
inline void SatParameters::set_stop_after_root_propagation(bool value) {
  _internal_set_stop_after_root_propagation(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_root_propagation)
}
inline bool SatParameters::_internal_stop_after_root_propagation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.stop_after_root_propagation_;
}
inline void SatParameters::_internal_set_stop_after_root_propagation(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.stop_after_root_propagation_ = value;
}
 
// optional double lns_initial_difficulty = 307 [default = 0.5];
inline bool SatParameters::has_lns_initial_difficulty() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00080000U);
  return value;
}
inline void SatParameters::clear_lns_initial_difficulty() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lns_initial_difficulty_ = 0.5;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00080000U);
}
inline double SatParameters::lns_initial_difficulty() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lns_initial_difficulty)
  return _internal_lns_initial_difficulty();
}
inline void SatParameters::set_lns_initial_difficulty(double value) {
  _internal_set_lns_initial_difficulty(value);
  SetHasBit(_impl_._has_bits_[8], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lns_initial_difficulty)
}
inline double SatParameters::_internal_lns_initial_difficulty() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.lns_initial_difficulty_;
}
inline void SatParameters::_internal_set_lns_initial_difficulty(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lns_initial_difficulty_ = value;
}
 
// optional double lns_initial_deterministic_limit = 308 [default = 0.1];
inline bool SatParameters::has_lns_initial_deterministic_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00100000U);
  return value;
}
inline void SatParameters::clear_lns_initial_deterministic_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lns_initial_deterministic_limit_ = 0.1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00100000U);
}
inline double SatParameters::lns_initial_deterministic_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lns_initial_deterministic_limit)
  return _internal_lns_initial_deterministic_limit();
}
inline void SatParameters::set_lns_initial_deterministic_limit(double value) {
  _internal_set_lns_initial_deterministic_limit(value);
  SetHasBit(_impl_._has_bits_[8], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lns_initial_deterministic_limit)
}
inline double SatParameters::_internal_lns_initial_deterministic_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.lns_initial_deterministic_limit_;
}
inline void SatParameters::_internal_set_lns_initial_deterministic_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lns_initial_deterministic_limit_ = value;
}
 
// optional bool use_lns = 283 [default = true];
inline bool SatParameters::has_use_lns() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000400U);
  return value;
}
inline void SatParameters::clear_use_lns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_lns_ = true;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000400U);
}
inline bool SatParameters::use_lns() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_lns)
  return _internal_use_lns();
}
inline void SatParameters::set_use_lns(bool value) {
  _internal_set_use_lns(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_lns)
}
inline bool SatParameters::_internal_use_lns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_lns_;
}
inline void SatParameters::_internal_set_use_lns(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_lns_ = value;
}
 
// optional bool use_lns_only = 101 [default = false];
inline bool SatParameters::has_use_lns_only() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00100000U);
  return value;
}
inline void SatParameters::clear_use_lns_only() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_lns_only_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00100000U);
}
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::set_use_lns_only(bool value) {
  _internal_set_use_lns_only(value);
  SetHasBit(_impl_._has_bits_[1], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_lns_only)
}
inline bool SatParameters::_internal_use_lns_only() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_lns_only_;
}
inline void SatParameters::_internal_set_use_lns_only(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_lns_only_ = value;
}
 
// optional int32 solution_pool_size = 193 [default = 3];
inline bool SatParameters::has_solution_pool_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x04000000U);
  return value;
}
inline void SatParameters::clear_solution_pool_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_pool_size_ = 3;
  ClearHasBit(_impl_._has_bits_[6],
                  0x04000000U);
}
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::set_solution_pool_size(::int32_t value) {
  _internal_set_solution_pool_size(value);
  SetHasBit(_impl_._has_bits_[6], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.solution_pool_size)
}
inline ::int32_t SatParameters::_internal_solution_pool_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.solution_pool_size_;
}
inline void SatParameters::_internal_set_solution_pool_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_pool_size_ = value;
}
 
// optional int32 solution_pool_diversity_limit = 329 [default = 10];
inline bool SatParameters::has_solution_pool_diversity_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000008U);
  return value;
}
inline void SatParameters::clear_solution_pool_diversity_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_pool_diversity_limit_ = 10;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000008U);
}
inline ::int32_t SatParameters::solution_pool_diversity_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.solution_pool_diversity_limit)
  return _internal_solution_pool_diversity_limit();
}
inline void SatParameters::set_solution_pool_diversity_limit(::int32_t value) {
  _internal_set_solution_pool_diversity_limit(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.solution_pool_diversity_limit)
}
inline ::int32_t SatParameters::_internal_solution_pool_diversity_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.solution_pool_diversity_limit_;
}
inline void SatParameters::_internal_set_solution_pool_diversity_limit(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_pool_diversity_limit_ = value;
}
 
// optional int32 alternative_pool_size = 325 [default = 1];
inline bool SatParameters::has_alternative_pool_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000001U);
  return value;
}
inline void SatParameters::clear_alternative_pool_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alternative_pool_size_ = 1;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000001U);
}
inline ::int32_t SatParameters::alternative_pool_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.alternative_pool_size)
  return _internal_alternative_pool_size();
}
inline void SatParameters::set_alternative_pool_size(::int32_t value) {
  _internal_set_alternative_pool_size(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.alternative_pool_size)
}
inline ::int32_t SatParameters::_internal_alternative_pool_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.alternative_pool_size_;
}
inline void SatParameters::_internal_set_alternative_pool_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.alternative_pool_size_ = value;
}
 
// optional bool use_rins_lns = 129 [default = true];
inline bool SatParameters::has_use_rins_lns() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00200000U);
  return value;
}
inline void SatParameters::clear_use_rins_lns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_rins_lns_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00200000U);
}
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::set_use_rins_lns(bool value) {
  _internal_set_use_rins_lns(value);
  SetHasBit(_impl_._has_bits_[5], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_rins_lns)
}
inline bool SatParameters::_internal_use_rins_lns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_rins_lns_;
}
inline void SatParameters::_internal_set_use_rins_lns(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_rins_lns_ = value;
}
 
// optional bool use_feasibility_pump = 164 [default = true];
inline bool SatParameters::has_use_feasibility_pump() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00008000U);
  return value;
}
inline void SatParameters::clear_use_feasibility_pump() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_feasibility_pump_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00008000U);
}
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::set_use_feasibility_pump(bool value) {
  _internal_set_use_feasibility_pump(value);
  SetHasBit(_impl_._has_bits_[6], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_feasibility_pump)
}
inline bool SatParameters::_internal_use_feasibility_pump() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_feasibility_pump_;
}
inline void SatParameters::_internal_set_use_feasibility_pump(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_feasibility_pump_ = value;
}
 
// optional bool use_lb_relax_lns = 255 [default = true];
inline bool SatParameters::has_use_lb_relax_lns() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x10000000U);
  return value;
}
inline void SatParameters::clear_use_lb_relax_lns() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_lb_relax_lns_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x10000000U);
}
inline bool SatParameters::use_lb_relax_lns() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_lb_relax_lns)
  return _internal_use_lb_relax_lns();
}
inline void SatParameters::set_use_lb_relax_lns(bool value) {
  _internal_set_use_lb_relax_lns(value);
  SetHasBit(_impl_._has_bits_[7], 0x10000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_lb_relax_lns)
}
inline bool SatParameters::_internal_use_lb_relax_lns() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_lb_relax_lns_;
}
inline void SatParameters::_internal_set_use_lb_relax_lns(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_lb_relax_lns_ = value;
}
 
// optional int32 lb_relax_num_workers_threshold = 296 [default = 16];
inline bool SatParameters::has_lb_relax_num_workers_threshold() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00010000U);
  return value;
}
inline void SatParameters::clear_lb_relax_num_workers_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lb_relax_num_workers_threshold_ = 16;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00010000U);
}
inline ::int32_t SatParameters::lb_relax_num_workers_threshold() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lb_relax_num_workers_threshold)
  return _internal_lb_relax_num_workers_threshold();
}
inline void SatParameters::set_lb_relax_num_workers_threshold(::int32_t value) {
  _internal_set_lb_relax_num_workers_threshold(value);
  SetHasBit(_impl_._has_bits_[8], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lb_relax_num_workers_threshold)
}
inline ::int32_t SatParameters::_internal_lb_relax_num_workers_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.lb_relax_num_workers_threshold_;
}
inline void SatParameters::_internal_set_lb_relax_num_workers_threshold(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lb_relax_num_workers_threshold_ = value;
}
 
// optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
inline bool SatParameters::has_fp_rounding() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00002000U);
  return value;
}
inline void SatParameters::clear_fp_rounding() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.fp_rounding_ = 2;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00002000U);
}
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::set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value) {
  _internal_set_fp_rounding(value);
  SetHasBit(_impl_._has_bits_[6], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fp_rounding)
}
inline ::operations_research::sat::SatParameters_FPRoundingMethod SatParameters::_internal_fp_rounding() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::sat::SatParameters_FPRoundingMethod>(_impl_.fp_rounding_);
}
inline void SatParameters::_internal_set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::operations_research::sat::SatParameters_FPRoundingMethod_internal_data_));
                                          _impl_.fp_rounding_ = value;
}
 
// optional bool diversify_lns_params = 137 [default = false];
inline bool SatParameters::has_diversify_lns_params() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x10000000U);
  return value;
}
inline void SatParameters::clear_diversify_lns_params() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.diversify_lns_params_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x10000000U);
}
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::set_diversify_lns_params(bool value) {
  _internal_set_diversify_lns_params(value);
  SetHasBit(_impl_._has_bits_[1], 0x10000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.diversify_lns_params)
}
inline bool SatParameters::_internal_diversify_lns_params() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.diversify_lns_params_;
}
inline void SatParameters::_internal_set_diversify_lns_params(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.diversify_lns_params_ = value;
}
 
// optional bool randomize_search = 103 [default = false];
inline bool SatParameters::has_randomize_search() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00200000U);
  return value;
}
inline void SatParameters::clear_randomize_search() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.randomize_search_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00200000U);
}
inline bool SatParameters::randomize_search() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.randomize_search)
  return _internal_randomize_search();
}
inline void SatParameters::set_randomize_search(bool value) {
  _internal_set_randomize_search(value);
  SetHasBit(_impl_._has_bits_[1], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.randomize_search)
}
inline bool SatParameters::_internal_randomize_search() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.randomize_search_;
}
inline void SatParameters::_internal_set_randomize_search(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.randomize_search_ = value;
}
 
// optional int64 search_random_variable_pool_size = 104 [default = 0];
inline bool SatParameters::has_search_random_variable_pool_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00080000U);
  return value;
}
inline void SatParameters::clear_search_random_variable_pool_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.search_random_variable_pool_size_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[1],
                  0x00080000U);
}
inline ::int64_t SatParameters::search_random_variable_pool_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.search_random_variable_pool_size)
  return _internal_search_random_variable_pool_size();
}
inline void SatParameters::set_search_random_variable_pool_size(::int64_t value) {
  _internal_set_search_random_variable_pool_size(value);
  SetHasBit(_impl_._has_bits_[1], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.search_random_variable_pool_size)
}
inline ::int64_t SatParameters::_internal_search_random_variable_pool_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.search_random_variable_pool_size_;
}
inline void SatParameters::_internal_set_search_random_variable_pool_size(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.search_random_variable_pool_size_ = value;
}
 
// optional bool push_all_tasks_toward_start = 262 [default = false];
inline bool SatParameters::has_push_all_tasks_toward_start() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000010U);
  return value;
}
inline void SatParameters::clear_push_all_tasks_toward_start() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.push_all_tasks_toward_start_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000010U);
}
inline bool SatParameters::push_all_tasks_toward_start() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.push_all_tasks_toward_start)
  return _internal_push_all_tasks_toward_start();
}
inline void SatParameters::set_push_all_tasks_toward_start(bool value) {
  _internal_set_push_all_tasks_toward_start(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.push_all_tasks_toward_start)
}
inline bool SatParameters::_internal_push_all_tasks_toward_start() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.push_all_tasks_toward_start_;
}
inline void SatParameters::_internal_set_push_all_tasks_toward_start(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.push_all_tasks_toward_start_ = value;
}
 
// optional bool use_optional_variables = 108 [default = false];
inline bool SatParameters::has_use_optional_variables() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00400000U);
  return value;
}
inline void SatParameters::clear_use_optional_variables() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_optional_variables_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00400000U);
}
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::set_use_optional_variables(bool value) {
  _internal_set_use_optional_variables(value);
  SetHasBit(_impl_._has_bits_[1], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_optional_variables)
}
inline bool SatParameters::_internal_use_optional_variables() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_optional_variables_;
}
inline void SatParameters::_internal_set_use_optional_variables(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_optional_variables_ = value;
}
 
// optional bool use_exact_lp_reason = 109 [default = true];
inline bool SatParameters::has_use_exact_lp_reason() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00001000U);
  return value;
}
inline void SatParameters::clear_use_exact_lp_reason() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_exact_lp_reason_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00001000U);
}
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::set_use_exact_lp_reason(bool value) {
  _internal_set_use_exact_lp_reason(value);
  SetHasBit(_impl_._has_bits_[5], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_exact_lp_reason)
}
inline bool SatParameters::_internal_use_exact_lp_reason() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_exact_lp_reason_;
}
inline void SatParameters::_internal_set_use_exact_lp_reason(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_exact_lp_reason_ = value;
}
 
// optional bool use_combined_no_overlap = 133 [default = false];
inline bool SatParameters::has_use_combined_no_overlap() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x04000000U);
  return value;
}
inline void SatParameters::clear_use_combined_no_overlap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_combined_no_overlap_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x04000000U);
}
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::set_use_combined_no_overlap(bool value) {
  _internal_set_use_combined_no_overlap(value);
  SetHasBit(_impl_._has_bits_[1], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_combined_no_overlap)
}
inline bool SatParameters::_internal_use_combined_no_overlap() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_combined_no_overlap_;
}
inline void SatParameters::_internal_set_use_combined_no_overlap(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_combined_no_overlap_ = value;
}
 
// optional int32 at_most_one_max_expansion_size = 270 [default = 3];
inline bool SatParameters::has_at_most_one_max_expansion_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000002U);
  return value;
}
inline void SatParameters::clear_at_most_one_max_expansion_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.at_most_one_max_expansion_size_ = 3;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000002U);
}
inline ::int32_t SatParameters::at_most_one_max_expansion_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.at_most_one_max_expansion_size)
  return _internal_at_most_one_max_expansion_size();
}
inline void SatParameters::set_at_most_one_max_expansion_size(::int32_t value) {
  _internal_set_at_most_one_max_expansion_size(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.at_most_one_max_expansion_size)
}
inline ::int32_t SatParameters::_internal_at_most_one_max_expansion_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.at_most_one_max_expansion_size_;
}
inline void SatParameters::_internal_set_at_most_one_max_expansion_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.at_most_one_max_expansion_size_ = value;
}
 
// optional bool catch_sigint_signal = 135 [default = true];
inline bool SatParameters::has_catch_sigint_signal() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000001U);
  return value;
}
inline void SatParameters::clear_catch_sigint_signal() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.catch_sigint_signal_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000001U);
}
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::set_catch_sigint_signal(bool value) {
  _internal_set_catch_sigint_signal(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.catch_sigint_signal)
}
inline bool SatParameters::_internal_catch_sigint_signal() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.catch_sigint_signal_;
}
inline void SatParameters::_internal_set_catch_sigint_signal(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.catch_sigint_signal_ = value;
}
 
// optional bool use_implied_bounds = 144 [default = true];
inline bool SatParameters::has_use_implied_bounds() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000002U);
  return value;
}
inline void SatParameters::clear_use_implied_bounds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_implied_bounds_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000002U);
}
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::set_use_implied_bounds(bool value) {
  _internal_set_use_implied_bounds(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_implied_bounds)
}
inline bool SatParameters::_internal_use_implied_bounds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_implied_bounds_;
}
inline void SatParameters::_internal_set_use_implied_bounds(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_implied_bounds_ = value;
}
 
// optional bool polish_lp_solution = 175 [default = false];
inline bool SatParameters::has_polish_lp_solution() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000040U);
  return value;
}
inline void SatParameters::clear_polish_lp_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.polish_lp_solution_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000040U);
}
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::set_polish_lp_solution(bool value) {
  _internal_set_polish_lp_solution(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.polish_lp_solution)
}
inline bool SatParameters::_internal_polish_lp_solution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.polish_lp_solution_;
}
inline void SatParameters::_internal_set_polish_lp_solution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.polish_lp_solution_ = value;
}
 
// optional double lp_primal_tolerance = 266 [default = 1e-07];
inline bool SatParameters::has_lp_primal_tolerance() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x04000000U);
  return value;
}
inline void SatParameters::clear_lp_primal_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lp_primal_tolerance_ = 1e-07;
  ClearHasBit(_impl_._has_bits_[7],
                  0x04000000U);
}
inline double SatParameters::lp_primal_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lp_primal_tolerance)
  return _internal_lp_primal_tolerance();
}
inline void SatParameters::set_lp_primal_tolerance(double value) {
  _internal_set_lp_primal_tolerance(value);
  SetHasBit(_impl_._has_bits_[7], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lp_primal_tolerance)
}
inline double SatParameters::_internal_lp_primal_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.lp_primal_tolerance_;
}
inline void SatParameters::_internal_set_lp_primal_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lp_primal_tolerance_ = value;
}
 
// optional double lp_dual_tolerance = 267 [default = 1e-07];
inline bool SatParameters::has_lp_dual_tolerance() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00000001U);
  return value;
}
inline void SatParameters::clear_lp_dual_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lp_dual_tolerance_ = 1e-07;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00000001U);
}
inline double SatParameters::lp_dual_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lp_dual_tolerance)
  return _internal_lp_dual_tolerance();
}
inline void SatParameters::set_lp_dual_tolerance(double value) {
  _internal_set_lp_dual_tolerance(value);
  SetHasBit(_impl_._has_bits_[8], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lp_dual_tolerance)
}
inline double SatParameters::_internal_lp_dual_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.lp_dual_tolerance_;
}
inline void SatParameters::_internal_set_lp_dual_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lp_dual_tolerance_ = value;
}
 
// optional bool convert_intervals = 177 [default = true];
inline bool SatParameters::has_convert_intervals() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00100000U);
  return value;
}
inline void SatParameters::clear_convert_intervals() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.convert_intervals_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00100000U);
}
inline bool SatParameters::convert_intervals() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.convert_intervals)
  return _internal_convert_intervals();
}
inline void SatParameters::set_convert_intervals(bool value) {
  _internal_set_convert_intervals(value);
  SetHasBit(_impl_._has_bits_[6], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.convert_intervals)
}
inline bool SatParameters::_internal_convert_intervals() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.convert_intervals_;
}
inline void SatParameters::_internal_set_convert_intervals(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.convert_intervals_ = value;
}
 
// optional int32 symmetry_level = 183 [default = 2];
inline bool SatParameters::has_symmetry_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00800000U);
  return value;
}
inline void SatParameters::clear_symmetry_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.symmetry_level_ = 2;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00800000U);
}
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::set_symmetry_level(::int32_t value) {
  _internal_set_symmetry_level(value);
  SetHasBit(_impl_._has_bits_[6], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.symmetry_level)
}
inline ::int32_t SatParameters::_internal_symmetry_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.symmetry_level_;
}
inline void SatParameters::_internal_set_symmetry_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.symmetry_level_ = value;
}
 
// optional bool use_symmetry_in_lp = 301 [default = false];
inline bool SatParameters::has_use_symmetry_in_lp() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00080000U);
  return value;
}
inline void SatParameters::clear_use_symmetry_in_lp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_symmetry_in_lp_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00080000U);
}
inline bool SatParameters::use_symmetry_in_lp() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_symmetry_in_lp)
  return _internal_use_symmetry_in_lp();
}
inline void SatParameters::set_use_symmetry_in_lp(bool value) {
  _internal_set_use_symmetry_in_lp(value);
  SetHasBit(_impl_._has_bits_[3], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_symmetry_in_lp)
}
inline bool SatParameters::_internal_use_symmetry_in_lp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_symmetry_in_lp_;
}
inline void SatParameters::_internal_set_use_symmetry_in_lp(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_symmetry_in_lp_ = value;
}
 
// optional bool keep_symmetry_in_presolve = 303 [default = false];
inline bool SatParameters::has_keep_symmetry_in_presolve() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00100000U);
  return value;
}
inline void SatParameters::clear_keep_symmetry_in_presolve() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.keep_symmetry_in_presolve_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00100000U);
}
inline bool SatParameters::keep_symmetry_in_presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.keep_symmetry_in_presolve)
  return _internal_keep_symmetry_in_presolve();
}
inline void SatParameters::set_keep_symmetry_in_presolve(bool value) {
  _internal_set_keep_symmetry_in_presolve(value);
  SetHasBit(_impl_._has_bits_[3], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.keep_symmetry_in_presolve)
}
inline bool SatParameters::_internal_keep_symmetry_in_presolve() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.keep_symmetry_in_presolve_;
}
inline void SatParameters::_internal_set_keep_symmetry_in_presolve(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.keep_symmetry_in_presolve_ = value;
}
 
// optional double symmetry_detection_deterministic_time_limit = 302 [default = 1];
inline bool SatParameters::has_symmetry_detection_deterministic_time_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[8], 0x00040000U);
  return value;
}
inline void SatParameters::clear_symmetry_detection_deterministic_time_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.symmetry_detection_deterministic_time_limit_ = 1;
  ClearHasBit(_impl_._has_bits_[8],
                  0x00040000U);
}
inline double SatParameters::symmetry_detection_deterministic_time_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.symmetry_detection_deterministic_time_limit)
  return _internal_symmetry_detection_deterministic_time_limit();
}
inline void SatParameters::set_symmetry_detection_deterministic_time_limit(double value) {
  _internal_set_symmetry_detection_deterministic_time_limit(value);
  SetHasBit(_impl_._has_bits_[8], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.symmetry_detection_deterministic_time_limit)
}
inline double SatParameters::_internal_symmetry_detection_deterministic_time_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.symmetry_detection_deterministic_time_limit_;
}
inline void SatParameters::_internal_set_symmetry_detection_deterministic_time_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.symmetry_detection_deterministic_time_limit_ = value;
}
 
// optional bool new_linear_propagation = 224 [default = true];
inline bool SatParameters::has_new_linear_propagation() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000800U);
  return value;
}
inline void SatParameters::clear_new_linear_propagation() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.new_linear_propagation_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000800U);
}
inline bool SatParameters::new_linear_propagation() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.new_linear_propagation)
  return _internal_new_linear_propagation();
}
inline void SatParameters::set_new_linear_propagation(bool value) {
  _internal_set_new_linear_propagation(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.new_linear_propagation)
}
inline bool SatParameters::_internal_new_linear_propagation() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.new_linear_propagation_;
}
inline void SatParameters::_internal_set_new_linear_propagation(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.new_linear_propagation_ = value;
}
 
// optional int32 linear_split_size = 256 [default = 100];
inline bool SatParameters::has_linear_split_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00100000U);
  return value;
}
inline void SatParameters::clear_linear_split_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.linear_split_size_ = 100;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00100000U);
}
inline ::int32_t SatParameters::linear_split_size() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.linear_split_size)
  return _internal_linear_split_size();
}
inline void SatParameters::set_linear_split_size(::int32_t value) {
  _internal_set_linear_split_size(value);
  SetHasBit(_impl_._has_bits_[7], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.linear_split_size)
}
inline ::int32_t SatParameters::_internal_linear_split_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.linear_split_size_;
}
inline void SatParameters::_internal_set_linear_split_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.linear_split_size_ = value;
}
 
// optional int32 linearization_level = 90 [default = 1];
inline bool SatParameters::has_linearization_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000008U);
  return value;
}
inline void SatParameters::clear_linearization_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.linearization_level_ = 1;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000008U);
}
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::set_linearization_level(::int32_t value) {
  _internal_set_linearization_level(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.linearization_level)
}
inline ::int32_t SatParameters::_internal_linearization_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.linearization_level_;
}
inline void SatParameters::_internal_set_linearization_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.linearization_level_ = value;
}
 
// optional int32 boolean_encoding_level = 107 [default = 1];
inline bool SatParameters::has_boolean_encoding_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000400U);
  return value;
}
inline void SatParameters::clear_boolean_encoding_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.boolean_encoding_level_ = 1;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000400U);
}
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::set_boolean_encoding_level(::int32_t value) {
  _internal_set_boolean_encoding_level(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.boolean_encoding_level)
}
inline ::int32_t SatParameters::_internal_boolean_encoding_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.boolean_encoding_level_;
}
inline void SatParameters::_internal_set_boolean_encoding_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.boolean_encoding_level_ = value;
}
 
// optional int32 max_domain_size_when_encoding_eq_neq_constraints = 191 [default = 16];
inline bool SatParameters::has_max_domain_size_when_encoding_eq_neq_constraints() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x02000000U);
  return value;
}
inline void SatParameters::clear_max_domain_size_when_encoding_eq_neq_constraints() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_domain_size_when_encoding_eq_neq_constraints_ = 16;
  ClearHasBit(_impl_._has_bits_[6],
                  0x02000000U);
}
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::set_max_domain_size_when_encoding_eq_neq_constraints(::int32_t value) {
  _internal_set_max_domain_size_when_encoding_eq_neq_constraints(value);
  SetHasBit(_impl_._has_bits_[6], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_domain_size_when_encoding_eq_neq_constraints)
}
inline ::int32_t SatParameters::_internal_max_domain_size_when_encoding_eq_neq_constraints() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_domain_size_when_encoding_eq_neq_constraints_;
}
inline void SatParameters::_internal_set_max_domain_size_when_encoding_eq_neq_constraints(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_domain_size_when_encoding_eq_neq_constraints_ = value;
}
 
// optional int32 max_num_cuts = 91 [default = 10000];
inline bool SatParameters::has_max_num_cuts() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000010U);
  return value;
}
inline void SatParameters::clear_max_num_cuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_num_cuts_ = 10000;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000010U);
}
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::set_max_num_cuts(::int32_t value) {
  _internal_set_max_num_cuts(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_num_cuts)
}
inline ::int32_t SatParameters::_internal_max_num_cuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_num_cuts_;
}
inline void SatParameters::_internal_set_max_num_cuts(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_num_cuts_ = value;
}
 
// optional int32 cut_level = 196 [default = 1];
inline bool SatParameters::has_cut_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x20000000U);
  return value;
}
inline void SatParameters::clear_cut_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cut_level_ = 1;
  ClearHasBit(_impl_._has_bits_[6],
                  0x20000000U);
}
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::set_cut_level(::int32_t value) {
  _internal_set_cut_level(value);
  SetHasBit(_impl_._has_bits_[6], 0x20000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_level)
}
inline ::int32_t SatParameters::_internal_cut_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cut_level_;
}
inline void SatParameters::_internal_set_cut_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cut_level_ = value;
}
 
// optional bool only_add_cuts_at_level_zero = 92 [default = false];
inline bool SatParameters::has_only_add_cuts_at_level_zero() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00010000U);
  return value;
}
inline void SatParameters::clear_only_add_cuts_at_level_zero() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.only_add_cuts_at_level_zero_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00010000U);
}
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::set_only_add_cuts_at_level_zero(bool value) {
  _internal_set_only_add_cuts_at_level_zero(value);
  SetHasBit(_impl_._has_bits_[1], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.only_add_cuts_at_level_zero)
}
inline bool SatParameters::_internal_only_add_cuts_at_level_zero() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.only_add_cuts_at_level_zero_;
}
inline void SatParameters::_internal_set_only_add_cuts_at_level_zero(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.only_add_cuts_at_level_zero_ = value;
}
 
// optional bool add_objective_cut = 197 [default = false];
inline bool SatParameters::has_add_objective_cut() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00040000U);
  return value;
}
inline void SatParameters::clear_add_objective_cut() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_objective_cut_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00040000U);
}
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::set_add_objective_cut(bool value) {
  _internal_set_add_objective_cut(value);
  SetHasBit(_impl_._has_bits_[2], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_objective_cut)
}
inline bool SatParameters::_internal_add_objective_cut() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_objective_cut_;
}
inline void SatParameters::_internal_set_add_objective_cut(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_objective_cut_ = value;
}
 
// optional bool add_cg_cuts = 117 [default = true];
inline bool SatParameters::has_add_cg_cuts() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00080000U);
  return value;
}
inline void SatParameters::clear_add_cg_cuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_cg_cuts_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00080000U);
}
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::set_add_cg_cuts(bool value) {
  _internal_set_add_cg_cuts(value);
  SetHasBit(_impl_._has_bits_[5], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_cg_cuts)
}
inline bool SatParameters::_internal_add_cg_cuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_cg_cuts_;
}
inline void SatParameters::_internal_set_add_cg_cuts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_cg_cuts_ = value;
}
 
// optional bool add_mir_cuts = 120 [default = true];
inline bool SatParameters::has_add_mir_cuts() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00100000U);
  return value;
}
inline void SatParameters::clear_add_mir_cuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_mir_cuts_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00100000U);
}
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::set_add_mir_cuts(bool value) {
  _internal_set_add_mir_cuts(value);
  SetHasBit(_impl_._has_bits_[5], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_mir_cuts)
}
inline bool SatParameters::_internal_add_mir_cuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_mir_cuts_;
}
inline void SatParameters::_internal_set_add_mir_cuts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_mir_cuts_ = value;
}
 
// optional bool add_zero_half_cuts = 169 [default = true];
inline bool SatParameters::has_add_zero_half_cuts() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00020000U);
  return value;
}
inline void SatParameters::clear_add_zero_half_cuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_zero_half_cuts_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00020000U);
}
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::set_add_zero_half_cuts(bool value) {
  _internal_set_add_zero_half_cuts(value);
  SetHasBit(_impl_._has_bits_[6], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_zero_half_cuts)
}
inline bool SatParameters::_internal_add_zero_half_cuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_zero_half_cuts_;
}
inline void SatParameters::_internal_set_add_zero_half_cuts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_zero_half_cuts_ = value;
}
 
// optional bool add_clique_cuts = 172 [default = true];
inline bool SatParameters::has_add_clique_cuts() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00080000U);
  return value;
}
inline void SatParameters::clear_add_clique_cuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_clique_cuts_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00080000U);
}
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::set_add_clique_cuts(bool value) {
  _internal_set_add_clique_cuts(value);
  SetHasBit(_impl_._has_bits_[6], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_clique_cuts)
}
inline bool SatParameters::_internal_add_clique_cuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_clique_cuts_;
}
inline void SatParameters::_internal_set_add_clique_cuts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_clique_cuts_ = value;
}
 
// optional bool add_rlt_cuts = 279 [default = true];
inline bool SatParameters::has_add_rlt_cuts() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x80000000U);
  return value;
}
inline void SatParameters::clear_add_rlt_cuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_rlt_cuts_ = true;
  ClearHasBit(_impl_._has_bits_[7],
                  0x80000000U);
}
inline bool SatParameters::add_rlt_cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_rlt_cuts)
  return _internal_add_rlt_cuts();
}
inline void SatParameters::set_add_rlt_cuts(bool value) {
  _internal_set_add_rlt_cuts(value);
  SetHasBit(_impl_._has_bits_[7], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_rlt_cuts)
}
inline bool SatParameters::_internal_add_rlt_cuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_rlt_cuts_;
}
inline void SatParameters::_internal_set_add_rlt_cuts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_rlt_cuts_ = value;
}
 
// optional int32 max_all_diff_cut_size = 148 [default = 64];
inline bool SatParameters::has_max_all_diff_cut_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000040U);
  return value;
}
inline void SatParameters::clear_max_all_diff_cut_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_all_diff_cut_size_ = 64;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000040U);
}
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::set_max_all_diff_cut_size(::int32_t value) {
  _internal_set_max_all_diff_cut_size(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_all_diff_cut_size)
}
inline ::int32_t SatParameters::_internal_max_all_diff_cut_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_all_diff_cut_size_;
}
inline void SatParameters::_internal_set_max_all_diff_cut_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_all_diff_cut_size_ = value;
}
 
// optional bool add_lin_max_cuts = 152 [default = true];
inline bool SatParameters::has_add_lin_max_cuts() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000004U);
  return value;
}
inline void SatParameters::clear_add_lin_max_cuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_lin_max_cuts_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000004U);
}
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::set_add_lin_max_cuts(bool value) {
  _internal_set_add_lin_max_cuts(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_lin_max_cuts)
}
inline bool SatParameters::_internal_add_lin_max_cuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_lin_max_cuts_;
}
inline void SatParameters::_internal_set_add_lin_max_cuts(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_lin_max_cuts_ = value;
}
 
// optional int32 max_integer_rounding_scaling = 119 [default = 600];
inline bool SatParameters::has_max_integer_rounding_scaling() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00010000U);
  return value;
}
inline void SatParameters::clear_max_integer_rounding_scaling() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_integer_rounding_scaling_ = 600;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00010000U);
}
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::set_max_integer_rounding_scaling(::int32_t value) {
  _internal_set_max_integer_rounding_scaling(value);
  SetHasBit(_impl_._has_bits_[5], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_integer_rounding_scaling)
}
inline ::int32_t SatParameters::_internal_max_integer_rounding_scaling() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_integer_rounding_scaling_;
}
inline void SatParameters::_internal_set_max_integer_rounding_scaling(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_integer_rounding_scaling_ = value;
}
 
// optional bool add_lp_constraints_lazily = 112 [default = true];
inline bool SatParameters::has_add_lp_constraints_lazily() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00002000U);
  return value;
}
inline void SatParameters::clear_add_lp_constraints_lazily() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_lp_constraints_lazily_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00002000U);
}
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::set_add_lp_constraints_lazily(bool value) {
  _internal_set_add_lp_constraints_lazily(value);
  SetHasBit(_impl_._has_bits_[5], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_lp_constraints_lazily)
}
inline bool SatParameters::_internal_add_lp_constraints_lazily() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_lp_constraints_lazily_;
}
inline void SatParameters::_internal_set_add_lp_constraints_lazily(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_lp_constraints_lazily_ = value;
}
 
// optional int32 root_lp_iterations = 227 [default = 2000];
inline bool SatParameters::has_root_lp_iterations() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000040U);
  return value;
}
inline void SatParameters::clear_root_lp_iterations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.root_lp_iterations_ = 2000;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000040U);
}
inline ::int32_t SatParameters::root_lp_iterations() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.root_lp_iterations)
  return _internal_root_lp_iterations();
}
inline void SatParameters::set_root_lp_iterations(::int32_t value) {
  _internal_set_root_lp_iterations(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.root_lp_iterations)
}
inline ::int32_t SatParameters::_internal_root_lp_iterations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.root_lp_iterations_;
}
inline void SatParameters::_internal_set_root_lp_iterations(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.root_lp_iterations_ = value;
}
 
// optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
inline bool SatParameters::has_min_orthogonality_for_lp_constraints() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00020000U);
  return value;
}
inline void SatParameters::clear_min_orthogonality_for_lp_constraints() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.min_orthogonality_for_lp_constraints_ = 0.05;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00020000U);
}
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::set_min_orthogonality_for_lp_constraints(double value) {
  _internal_set_min_orthogonality_for_lp_constraints(value);
  SetHasBit(_impl_._has_bits_[5], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
}
inline double SatParameters::_internal_min_orthogonality_for_lp_constraints() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.min_orthogonality_for_lp_constraints_;
}
inline void SatParameters::_internal_set_min_orthogonality_for_lp_constraints(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.min_orthogonality_for_lp_constraints_ = value;
}
 
// optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
inline bool SatParameters::has_max_cut_rounds_at_level_zero() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000100U);
  return value;
}
inline void SatParameters::clear_max_cut_rounds_at_level_zero() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_cut_rounds_at_level_zero_ = 1;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000100U);
}
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::set_max_cut_rounds_at_level_zero(::int32_t value) {
  _internal_set_max_cut_rounds_at_level_zero(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_cut_rounds_at_level_zero)
}
inline ::int32_t SatParameters::_internal_max_cut_rounds_at_level_zero() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_cut_rounds_at_level_zero_;
}
inline void SatParameters::_internal_set_max_cut_rounds_at_level_zero(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_cut_rounds_at_level_zero_ = value;
}
 
// optional int32 max_consecutive_inactive_count = 121 [default = 100];
inline bool SatParameters::has_max_consecutive_inactive_count() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00400000U);
  return value;
}
inline void SatParameters::clear_max_consecutive_inactive_count() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_consecutive_inactive_count_ = 100;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00400000U);
}
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::set_max_consecutive_inactive_count(::int32_t value) {
  _internal_set_max_consecutive_inactive_count(value);
  SetHasBit(_impl_._has_bits_[5], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_consecutive_inactive_count)
}
inline ::int32_t SatParameters::_internal_max_consecutive_inactive_count() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_consecutive_inactive_count_;
}
inline void SatParameters::_internal_set_max_consecutive_inactive_count(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_consecutive_inactive_count_ = value;
}
 
// optional double cut_max_active_count_value = 155 [default = 10000000000];
inline bool SatParameters::has_cut_max_active_count_value() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000200U);
  return value;
}
inline void SatParameters::clear_cut_max_active_count_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cut_max_active_count_value_ = 10000000000;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000200U);
}
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::set_cut_max_active_count_value(double value) {
  _internal_set_cut_max_active_count_value(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_max_active_count_value)
}
inline double SatParameters::_internal_cut_max_active_count_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cut_max_active_count_value_;
}
inline void SatParameters::_internal_set_cut_max_active_count_value(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cut_max_active_count_value_ = value;
}
 
// optional double cut_active_count_decay = 156 [default = 0.8];
inline bool SatParameters::has_cut_active_count_decay() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00000400U);
  return value;
}
inline void SatParameters::clear_cut_active_count_decay() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cut_active_count_decay_ = 0.8;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00000400U);
}
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::set_cut_active_count_decay(double value) {
  _internal_set_cut_active_count_decay(value);
  SetHasBit(_impl_._has_bits_[6], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_active_count_decay)
}
inline double SatParameters::_internal_cut_active_count_decay() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cut_active_count_decay_;
}
inline void SatParameters::_internal_set_cut_active_count_decay(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cut_active_count_decay_ = value;
}
 
// optional int32 cut_cleanup_target = 157 [default = 1000];
inline bool SatParameters::has_cut_cleanup_target() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00001000U);
  return value;
}
inline void SatParameters::clear_cut_cleanup_target() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cut_cleanup_target_ = 1000;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00001000U);
}
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::set_cut_cleanup_target(::int32_t value) {
  _internal_set_cut_cleanup_target(value);
  SetHasBit(_impl_._has_bits_[6], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_cleanup_target)
}
inline ::int32_t SatParameters::_internal_cut_cleanup_target() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cut_cleanup_target_;
}
inline void SatParameters::_internal_set_cut_cleanup_target(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cut_cleanup_target_ = value;
}
 
// optional int32 new_constraints_batch_size = 122 [default = 50];
inline bool SatParameters::has_new_constraints_batch_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x02000000U);
  return value;
}
inline void SatParameters::clear_new_constraints_batch_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.new_constraints_batch_size_ = 50;
  ClearHasBit(_impl_._has_bits_[5],
                  0x02000000U);
}
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::set_new_constraints_batch_size(::int32_t value) {
  _internal_set_new_constraints_batch_size(value);
  SetHasBit(_impl_._has_bits_[5], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.new_constraints_batch_size)
}
inline ::int32_t SatParameters::_internal_new_constraints_batch_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.new_constraints_batch_size_;
}
inline void SatParameters::_internal_set_new_constraints_batch_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.new_constraints_batch_size_ = value;
}
 
// optional bool exploit_integer_lp_solution = 94 [default = true];
inline bool SatParameters::has_exploit_integer_lp_solution() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00000040U);
  return value;
}
inline void SatParameters::clear_exploit_integer_lp_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_integer_lp_solution_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00000040U);
}
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::set_exploit_integer_lp_solution(bool value) {
  _internal_set_exploit_integer_lp_solution(value);
  SetHasBit(_impl_._has_bits_[5], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_integer_lp_solution)
}
inline bool SatParameters::_internal_exploit_integer_lp_solution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exploit_integer_lp_solution_;
}
inline void SatParameters::_internal_set_exploit_integer_lp_solution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_integer_lp_solution_ = value;
}
 
// optional bool exploit_all_lp_solution = 116 [default = true];
inline bool SatParameters::has_exploit_all_lp_solution() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x00040000U);
  return value;
}
inline void SatParameters::clear_exploit_all_lp_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_all_lp_solution_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x00040000U);
}
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::set_exploit_all_lp_solution(bool value) {
  _internal_set_exploit_all_lp_solution(value);
  SetHasBit(_impl_._has_bits_[5], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_all_lp_solution)
}
inline bool SatParameters::_internal_exploit_all_lp_solution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exploit_all_lp_solution_;
}
inline void SatParameters::_internal_set_exploit_all_lp_solution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_all_lp_solution_ = value;
}
 
// optional bool exploit_best_solution = 130 [default = false];
inline bool SatParameters::has_exploit_best_solution() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00800000U);
  return value;
}
inline void SatParameters::clear_exploit_best_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_best_solution_ = false;
  ClearHasBit(_impl_._has_bits_[1],
                  0x00800000U);
}
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::set_exploit_best_solution(bool value) {
  _internal_set_exploit_best_solution(value);
  SetHasBit(_impl_._has_bits_[1], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_best_solution)
}
inline bool SatParameters::_internal_exploit_best_solution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exploit_best_solution_;
}
inline void SatParameters::_internal_set_exploit_best_solution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_best_solution_ = value;
}
 
// optional bool exploit_relaxation_solution = 161 [default = false];
inline bool SatParameters::has_exploit_relaxation_solution() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x00000001U);
  return value;
}
inline void SatParameters::clear_exploit_relaxation_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_relaxation_solution_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x00000001U);
}
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::set_exploit_relaxation_solution(bool value) {
  _internal_set_exploit_relaxation_solution(value);
  SetHasBit(_impl_._has_bits_[2], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_relaxation_solution)
}
inline bool SatParameters::_internal_exploit_relaxation_solution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exploit_relaxation_solution_;
}
inline void SatParameters::_internal_set_exploit_relaxation_solution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_relaxation_solution_ = value;
}
 
// optional bool exploit_objective = 131 [default = true];
inline bool SatParameters::has_exploit_objective() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x80000000U);
  return value;
}
inline void SatParameters::clear_exploit_objective() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_objective_ = true;
  ClearHasBit(_impl_._has_bits_[5],
                  0x80000000U);
}
inline bool SatParameters::exploit_objective() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_objective)
  return _internal_exploit_objective();
}
inline void SatParameters::set_exploit_objective(bool value) {
  _internal_set_exploit_objective(value);
  SetHasBit(_impl_._has_bits_[5], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_objective)
}
inline bool SatParameters::_internal_exploit_objective() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.exploit_objective_;
}
inline void SatParameters::_internal_set_exploit_objective(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.exploit_objective_ = value;
}
 
// optional bool detect_linearized_product = 277 [default = false];
inline bool SatParameters::has_detect_linearized_product() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000100U);
  return value;
}
inline void SatParameters::clear_detect_linearized_product() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.detect_linearized_product_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000100U);
}
inline bool SatParameters::detect_linearized_product() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.detect_linearized_product)
  return _internal_detect_linearized_product();
}
inline void SatParameters::set_detect_linearized_product(bool value) {
  _internal_set_detect_linearized_product(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.detect_linearized_product)
}
inline bool SatParameters::_internal_detect_linearized_product() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.detect_linearized_product_;
}
inline void SatParameters::_internal_set_detect_linearized_product(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.detect_linearized_product_ = value;
}
 
// optional bool use_new_integer_conflict_resolution = 336 [default = false];
inline bool SatParameters::has_use_new_integer_conflict_resolution() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x80000000U);
  return value;
}
inline void SatParameters::clear_use_new_integer_conflict_resolution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_new_integer_conflict_resolution_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x80000000U);
}
inline bool SatParameters::use_new_integer_conflict_resolution() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_new_integer_conflict_resolution)
  return _internal_use_new_integer_conflict_resolution();
}
inline void SatParameters::set_use_new_integer_conflict_resolution(bool value) {
  _internal_set_use_new_integer_conflict_resolution(value);
  SetHasBit(_impl_._has_bits_[3], 0x80000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_new_integer_conflict_resolution)
}
inline bool SatParameters::_internal_use_new_integer_conflict_resolution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_new_integer_conflict_resolution_;
}
inline void SatParameters::_internal_set_use_new_integer_conflict_resolution(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_new_integer_conflict_resolution_ = value;
}
 
// optional bool create_1uip_boolean_during_icr = 341 [default = true];
inline bool SatParameters::has_create_1uip_boolean_during_icr() const {
  bool value = CheckHasBit(_impl_._has_bits_[9], 0x00000100U);
  return value;
}
inline void SatParameters::clear_create_1uip_boolean_during_icr() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.create_1uip_boolean_during_icr_ = true;
  ClearHasBit(_impl_._has_bits_[9],
                  0x00000100U);
}
inline bool SatParameters::create_1uip_boolean_during_icr() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.create_1uip_boolean_during_icr)
  return _internal_create_1uip_boolean_during_icr();
}
inline void SatParameters::set_create_1uip_boolean_during_icr(bool value) {
  _internal_set_create_1uip_boolean_during_icr(value);
  SetHasBit(_impl_._has_bits_[9], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.create_1uip_boolean_during_icr)
}
inline bool SatParameters::_internal_create_1uip_boolean_during_icr() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.create_1uip_boolean_during_icr_;
}
inline void SatParameters::_internal_set_create_1uip_boolean_during_icr(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.create_1uip_boolean_during_icr_ = value;
}
 
// optional double mip_max_bound = 124 [default = 10000000];
inline bool SatParameters::has_mip_max_bound() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x01000000U);
  return value;
}
inline void SatParameters::clear_mip_max_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_max_bound_ = 10000000;
  ClearHasBit(_impl_._has_bits_[5],
                  0x01000000U);
}
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::set_mip_max_bound(double value) {
  _internal_set_mip_max_bound(value);
  SetHasBit(_impl_._has_bits_[5], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_bound)
}
inline double SatParameters::_internal_mip_max_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_max_bound_;
}
inline void SatParameters::_internal_set_mip_max_bound(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_max_bound_ = value;
}
 
// optional double mip_var_scaling = 125 [default = 1];
inline bool SatParameters::has_mip_var_scaling() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x08000000U);
  return value;
}
inline void SatParameters::clear_mip_var_scaling() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_var_scaling_ = 1;
  ClearHasBit(_impl_._has_bits_[5],
                  0x08000000U);
}
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::set_mip_var_scaling(double value) {
  _internal_set_mip_var_scaling(value);
  SetHasBit(_impl_._has_bits_[5], 0x08000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_var_scaling)
}
inline double SatParameters::_internal_mip_var_scaling() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_var_scaling_;
}
inline void SatParameters::_internal_set_mip_var_scaling(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_var_scaling_ = value;
}
 
// optional bool mip_scale_large_domain = 225 [default = false];
inline bool SatParameters::has_mip_scale_large_domain() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x08000000U);
  return value;
}
inline void SatParameters::clear_mip_scale_large_domain() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_scale_large_domain_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x08000000U);
}
inline bool SatParameters::mip_scale_large_domain() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_scale_large_domain)
  return _internal_mip_scale_large_domain();
}
inline void SatParameters::set_mip_scale_large_domain(bool value) {
  _internal_set_mip_scale_large_domain(value);
  SetHasBit(_impl_._has_bits_[2], 0x08000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_scale_large_domain)
}
inline bool SatParameters::_internal_mip_scale_large_domain() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_scale_large_domain_;
}
inline void SatParameters::_internal_set_mip_scale_large_domain(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_scale_large_domain_ = value;
}
 
// optional bool mip_automatically_scale_variables = 166 [default = true];
inline bool SatParameters::has_mip_automatically_scale_variables() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x00010000U);
  return value;
}
inline void SatParameters::clear_mip_automatically_scale_variables() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_automatically_scale_variables_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x00010000U);
}
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::set_mip_automatically_scale_variables(bool value) {
  _internal_set_mip_automatically_scale_variables(value);
  SetHasBit(_impl_._has_bits_[6], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_automatically_scale_variables)
}
inline bool SatParameters::_internal_mip_automatically_scale_variables() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_automatically_scale_variables_;
}
inline void SatParameters::_internal_set_mip_automatically_scale_variables(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_automatically_scale_variables_ = value;
}
 
// optional bool only_solve_ip = 222 [default = false];
inline bool SatParameters::has_only_solve_ip() const {
  bool value = CheckHasBit(_impl_._has_bits_[2], 0x02000000U);
  return value;
}
inline void SatParameters::clear_only_solve_ip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.only_solve_ip_ = false;
  ClearHasBit(_impl_._has_bits_[2],
                  0x02000000U);
}
inline bool SatParameters::only_solve_ip() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.only_solve_ip)
  return _internal_only_solve_ip();
}
inline void SatParameters::set_only_solve_ip(bool value) {
  _internal_set_only_solve_ip(value);
  SetHasBit(_impl_._has_bits_[2], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.only_solve_ip)
}
inline bool SatParameters::_internal_only_solve_ip() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.only_solve_ip_;
}
inline void SatParameters::_internal_set_only_solve_ip(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.only_solve_ip_ = value;
}
 
// optional double mip_wanted_precision = 126 [default = 1e-06];
inline bool SatParameters::has_mip_wanted_precision() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x10000000U);
  return value;
}
inline void SatParameters::clear_mip_wanted_precision() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_wanted_precision_ = 1e-06;
  ClearHasBit(_impl_._has_bits_[5],
                  0x10000000U);
}
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::set_mip_wanted_precision(double value) {
  _internal_set_mip_wanted_precision(value);
  SetHasBit(_impl_._has_bits_[5], 0x10000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_wanted_precision)
}
inline double SatParameters::_internal_mip_wanted_precision() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_wanted_precision_;
}
inline void SatParameters::_internal_set_mip_wanted_precision(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_wanted_precision_ = value;
}
 
// optional int32 mip_max_activity_exponent = 127 [default = 53];
inline bool SatParameters::has_mip_max_activity_exponent() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x04000000U);
  return value;
}
inline void SatParameters::clear_mip_max_activity_exponent() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_max_activity_exponent_ = 53;
  ClearHasBit(_impl_._has_bits_[5],
                  0x04000000U);
}
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::set_mip_max_activity_exponent(::int32_t value) {
  _internal_set_mip_max_activity_exponent(value);
  SetHasBit(_impl_._has_bits_[5], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_activity_exponent)
}
inline ::int32_t SatParameters::_internal_mip_max_activity_exponent() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_max_activity_exponent_;
}
inline void SatParameters::_internal_set_mip_max_activity_exponent(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_max_activity_exponent_ = value;
}
 
// optional double mip_check_precision = 128 [default = 0.0001];
inline bool SatParameters::has_mip_check_precision() const {
  bool value = CheckHasBit(_impl_._has_bits_[5], 0x20000000U);
  return value;
}
inline void SatParameters::clear_mip_check_precision() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_check_precision_ = 0.0001;
  ClearHasBit(_impl_._has_bits_[5],
                  0x20000000U);
}
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::set_mip_check_precision(double value) {
  _internal_set_mip_check_precision(value);
  SetHasBit(_impl_._has_bits_[5], 0x20000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_check_precision)
}
inline double SatParameters::_internal_mip_check_precision() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_check_precision_;
}
inline void SatParameters::_internal_set_mip_check_precision(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_check_precision_ = value;
}
 
// optional bool mip_compute_true_objective_bound = 198 [default = true];
inline bool SatParameters::has_mip_compute_true_objective_bound() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x40000000U);
  return value;
}
inline void SatParameters::clear_mip_compute_true_objective_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_compute_true_objective_bound_ = true;
  ClearHasBit(_impl_._has_bits_[6],
                  0x40000000U);
}
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::set_mip_compute_true_objective_bound(bool value) {
  _internal_set_mip_compute_true_objective_bound(value);
  SetHasBit(_impl_._has_bits_[6], 0x40000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_compute_true_objective_bound)
}
inline bool SatParameters::_internal_mip_compute_true_objective_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_compute_true_objective_bound_;
}
inline void SatParameters::_internal_set_mip_compute_true_objective_bound(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_compute_true_objective_bound_ = value;
}
 
// optional double mip_max_valid_magnitude = 199 [default = 1e+20];
inline bool SatParameters::has_mip_max_valid_magnitude() const {
  bool value = CheckHasBit(_impl_._has_bits_[6], 0x08000000U);
  return value;
}
inline void SatParameters::clear_mip_max_valid_magnitude() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_max_valid_magnitude_ = 1e+20;
  ClearHasBit(_impl_._has_bits_[6],
                  0x08000000U);
}
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::set_mip_max_valid_magnitude(double value) {
  _internal_set_mip_max_valid_magnitude(value);
  SetHasBit(_impl_._has_bits_[6], 0x08000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_valid_magnitude)
}
inline double SatParameters::_internal_mip_max_valid_magnitude() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_max_valid_magnitude_;
}
inline void SatParameters::_internal_set_mip_max_valid_magnitude(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_max_valid_magnitude_ = value;
}
 
// optional bool mip_treat_high_magnitude_bounds_as_infinity = 278 [default = false];
inline bool SatParameters::has_mip_treat_high_magnitude_bounds_as_infinity() const {
  bool value = CheckHasBit(_impl_._has_bits_[3], 0x00000200U);
  return value;
}
inline void SatParameters::clear_mip_treat_high_magnitude_bounds_as_infinity() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_treat_high_magnitude_bounds_as_infinity_ = false;
  ClearHasBit(_impl_._has_bits_[3],
                  0x00000200U);
}
inline bool SatParameters::mip_treat_high_magnitude_bounds_as_infinity() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_treat_high_magnitude_bounds_as_infinity)
  return _internal_mip_treat_high_magnitude_bounds_as_infinity();
}
inline void SatParameters::set_mip_treat_high_magnitude_bounds_as_infinity(bool value) {
  _internal_set_mip_treat_high_magnitude_bounds_as_infinity(value);
  SetHasBit(_impl_._has_bits_[3], 0x00000200U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_treat_high_magnitude_bounds_as_infinity)
}
inline bool SatParameters::_internal_mip_treat_high_magnitude_bounds_as_infinity() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_treat_high_magnitude_bounds_as_infinity_;
}
inline void SatParameters::_internal_set_mip_treat_high_magnitude_bounds_as_infinity(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_treat_high_magnitude_bounds_as_infinity_ = value;
}
 
// optional double mip_drop_tolerance = 232 [default = 1e-16];
inline bool SatParameters::has_mip_drop_tolerance() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x00000100U);
  return value;
}
inline void SatParameters::clear_mip_drop_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_drop_tolerance_ = 1e-16;
  ClearHasBit(_impl_._has_bits_[7],
                  0x00000100U);
}
inline double SatParameters::mip_drop_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_drop_tolerance)
  return _internal_mip_drop_tolerance();
}
inline void SatParameters::set_mip_drop_tolerance(double value) {
  _internal_set_mip_drop_tolerance(value);
  SetHasBit(_impl_._has_bits_[7], 0x00000100U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_drop_tolerance)
}
inline double SatParameters::_internal_mip_drop_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_drop_tolerance_;
}
inline void SatParameters::_internal_set_mip_drop_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_drop_tolerance_ = value;
}
 
// optional int32 mip_presolve_level = 261 [default = 2];
inline bool SatParameters::has_mip_presolve_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[7], 0x02000000U);
  return value;
}
inline void SatParameters::clear_mip_presolve_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_presolve_level_ = 2;
  ClearHasBit(_impl_._has_bits_[7],
                  0x02000000U);
}
inline ::int32_t SatParameters::mip_presolve_level() const {
  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_presolve_level)
  return _internal_mip_presolve_level();
}
inline void SatParameters::set_mip_presolve_level(::int32_t value) {
  _internal_set_mip_presolve_level(value);
  SetHasBit(_impl_._has_bits_[7], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_presolve_level)
}
inline ::int32_t SatParameters::_internal_mip_presolve_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mip_presolve_level_;
}
inline void SatParameters::_internal_set_mip_presolve_level(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mip_presolve_level_ = value;
}
 
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__
 
// @@protoc_insertion_point(namespace_scope)
}  // namespace sat
}  // namespace operations_research
 
 
namespace google {
namespace protobuf {
 
template <>
struct is_proto_enum<::operations_research::sat::SatParameters_VariableOrder> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL 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* PROTOBUF_NONNULL 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* PROTOBUF_NONNULL 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* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::sat::SatParameters_BinaryMinizationAlgorithm>() {
  return ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_descriptor();
}
template <>
struct is_proto_enum<::operations_research::sat::SatParameters_ClauseOrdering> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL 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* PROTOBUF_NONNULL 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* PROTOBUF_NONNULL 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* PROTOBUF_NONNULL 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* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::sat::SatParameters_SearchBranching>() {
  return ::operations_research::sat::SatParameters_SearchBranching_descriptor();
}
template <>
struct is_proto_enum<::operations_research::sat::SatParameters_SharedTreeSplitStrategy> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::sat::SatParameters_SharedTreeSplitStrategy>() {
  return ::operations_research::sat::SatParameters_SharedTreeSplitStrategy_descriptor();
}
template <>
struct is_proto_enum<::operations_research::sat::SatParameters_FPRoundingMethod> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::sat::SatParameters_FPRoundingMethod>() {
  return ::operations_research::sat::SatParameters_FPRoundingMethod_descriptor();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#include "google/protobuf/port_undef.inc"
 
#endif  // ortools_2fsat_2fsat_5fparameters_2eproto_2epb_2eh