C++ Reference

C++ Reference: CP-SAT

sat_parameters.pb.h
Go to the documentation of this file.
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: ortools/sat/sat_parameters.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
6 
7 #include <limits>
8 #include <string>
9 
10 #include <google/protobuf/port_def.inc>
11 #if PROTOBUF_VERSION < 3014000
12 #error This file was generated by a newer version of protoc which is
13 #error incompatible with your Protocol Buffer headers. Please update
14 #error your headers.
15 #endif
16 #if 3014000 < PROTOBUF_MIN_PROTOC_VERSION
17 #error This file was generated by an older version of protoc which is
18 #error incompatible with your Protocol Buffer headers. Please
19 #error regenerate this file with a newer version of protoc.
20 #endif
21 
22 #include <google/protobuf/port_undef.inc>
23 #include <google/protobuf/io/coded_stream.h>
24 #include <google/protobuf/arena.h>
25 #include <google/protobuf/arenastring.h>
26 #include <google/protobuf/generated_message_table_driven.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/generated_message_reflection.h>
30 #include <google/protobuf/message.h>
31 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
32 #include <google/protobuf/extension_set.h> // IWYU pragma: export
33 #include <google/protobuf/generated_enum_reflection.h>
34 #include <google/protobuf/unknown_field_set.h>
35 // @@protoc_insertion_point(includes)
36 #include <google/protobuf/port_def.inc>
37 #define PROTOBUF_INTERNAL_EXPORT_ortools_2fsat_2fsat_5fparameters_2eproto
38 PROTOBUF_NAMESPACE_OPEN
39 namespace internal {
40 class AnyMetadata;
41 } // namespace internal
42 PROTOBUF_NAMESPACE_CLOSE
43 
44 // Internal implementation detail -- do not use these members.
45 struct TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto {
46  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
47  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
48  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
49  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
50  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
51  PROTOBUF_SECTION_VARIABLE(protodesc_cold);
52  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
53  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
54  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
55 };
56 extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto;
57 namespace operations_research {
58 namespace sat {
59 class SatParameters;
60 class SatParametersDefaultTypeInternal;
61 extern SatParametersDefaultTypeInternal _SatParameters_default_instance_;
62 } // namespace sat
63 } // namespace operations_research
64 PROTOBUF_NAMESPACE_OPEN
65 template<> ::operations_research::sat::SatParameters* Arena::CreateMaybeMessage<::operations_research::sat::SatParameters>(Arena*);
66 PROTOBUF_NAMESPACE_CLOSE
67 namespace operations_research {
68 namespace sat {
69 
70 enum SatParameters_VariableOrder : int {
71  SatParameters_VariableOrder_IN_ORDER = 0,
72  SatParameters_VariableOrder_IN_REVERSE_ORDER = 1,
73  SatParameters_VariableOrder_IN_RANDOM_ORDER = 2
74 };
75 bool SatParameters_VariableOrder_IsValid(int value);
76 constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MIN = SatParameters_VariableOrder_IN_ORDER;
77 constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MAX = SatParameters_VariableOrder_IN_RANDOM_ORDER;
78 constexpr int SatParameters_VariableOrder_VariableOrder_ARRAYSIZE = SatParameters_VariableOrder_VariableOrder_MAX + 1;
79 
80 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_VariableOrder_descriptor();
81 template<typename T>
82 inline const std::string& SatParameters_VariableOrder_Name(T enum_t_value) {
83  static_assert(::std::is_same<T, SatParameters_VariableOrder>::value ||
84  ::std::is_integral<T>::value,
85  "Incorrect type passed to function SatParameters_VariableOrder_Name.");
86  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
87  SatParameters_VariableOrder_descriptor(), enum_t_value);
88 }
89 inline bool SatParameters_VariableOrder_Parse(
90  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_VariableOrder* value) {
91  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_VariableOrder>(
92  SatParameters_VariableOrder_descriptor(), name, value);
93 }
94 enum SatParameters_Polarity : int {
95  SatParameters_Polarity_POLARITY_TRUE = 0,
96  SatParameters_Polarity_POLARITY_FALSE = 1,
97  SatParameters_Polarity_POLARITY_RANDOM = 2,
98  SatParameters_Polarity_POLARITY_WEIGHTED_SIGN = 3,
99  SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN = 4
100 };
101 bool SatParameters_Polarity_IsValid(int value);
102 constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MIN = SatParameters_Polarity_POLARITY_TRUE;
103 constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MAX = SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN;
104 constexpr int SatParameters_Polarity_Polarity_ARRAYSIZE = SatParameters_Polarity_Polarity_MAX + 1;
105 
106 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_Polarity_descriptor();
107 template<typename T>
108 inline const std::string& SatParameters_Polarity_Name(T enum_t_value) {
109  static_assert(::std::is_same<T, SatParameters_Polarity>::value ||
110  ::std::is_integral<T>::value,
111  "Incorrect type passed to function SatParameters_Polarity_Name.");
112  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
113  SatParameters_Polarity_descriptor(), enum_t_value);
114 }
115 inline bool SatParameters_Polarity_Parse(
116  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_Polarity* value) {
117  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_Polarity>(
118  SatParameters_Polarity_descriptor(), name, value);
119 }
120 enum SatParameters_ConflictMinimizationAlgorithm : int {
121  SatParameters_ConflictMinimizationAlgorithm_NONE = 0,
122  SatParameters_ConflictMinimizationAlgorithm_SIMPLE = 1,
123  SatParameters_ConflictMinimizationAlgorithm_RECURSIVE = 2,
124  SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL = 3
125 };
126 bool SatParameters_ConflictMinimizationAlgorithm_IsValid(int value);
127 constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN = SatParameters_ConflictMinimizationAlgorithm_NONE;
128 constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX = SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL;
129 constexpr int SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE = SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX + 1;
130 
131 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ConflictMinimizationAlgorithm_descriptor();
132 template<typename T>
133 inline const std::string& SatParameters_ConflictMinimizationAlgorithm_Name(T enum_t_value) {
134  static_assert(::std::is_same<T, SatParameters_ConflictMinimizationAlgorithm>::value ||
135  ::std::is_integral<T>::value,
136  "Incorrect type passed to function SatParameters_ConflictMinimizationAlgorithm_Name.");
137  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
138  SatParameters_ConflictMinimizationAlgorithm_descriptor(), enum_t_value);
139 }
140 inline bool SatParameters_ConflictMinimizationAlgorithm_Parse(
141  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ConflictMinimizationAlgorithm* value) {
142  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ConflictMinimizationAlgorithm>(
143  SatParameters_ConflictMinimizationAlgorithm_descriptor(), name, value);
144 }
145 enum SatParameters_BinaryMinizationAlgorithm : int {
146  SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION = 0,
147  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST = 1,
148  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION = 4,
149  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY = 2,
150  SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION = 3
151 };
152 bool SatParameters_BinaryMinizationAlgorithm_IsValid(int value);
153 constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN = SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION;
154 constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX = SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION;
155 constexpr int SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE = SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX + 1;
156 
157 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_BinaryMinizationAlgorithm_descriptor();
158 template<typename T>
159 inline const std::string& SatParameters_BinaryMinizationAlgorithm_Name(T enum_t_value) {
160  static_assert(::std::is_same<T, SatParameters_BinaryMinizationAlgorithm>::value ||
161  ::std::is_integral<T>::value,
162  "Incorrect type passed to function SatParameters_BinaryMinizationAlgorithm_Name.");
163  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
164  SatParameters_BinaryMinizationAlgorithm_descriptor(), enum_t_value);
165 }
166 inline bool SatParameters_BinaryMinizationAlgorithm_Parse(
167  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_BinaryMinizationAlgorithm* value) {
168  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_BinaryMinizationAlgorithm>(
169  SatParameters_BinaryMinizationAlgorithm_descriptor(), name, value);
170 }
171 enum SatParameters_ClauseProtection : int {
172  SatParameters_ClauseProtection_PROTECTION_NONE = 0,
173  SatParameters_ClauseProtection_PROTECTION_ALWAYS = 1,
174  SatParameters_ClauseProtection_PROTECTION_LBD = 2
175 };
176 bool SatParameters_ClauseProtection_IsValid(int value);
177 constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MIN = SatParameters_ClauseProtection_PROTECTION_NONE;
178 constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MAX = SatParameters_ClauseProtection_PROTECTION_LBD;
179 constexpr int SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE = SatParameters_ClauseProtection_ClauseProtection_MAX + 1;
180 
181 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ClauseProtection_descriptor();
182 template<typename T>
183 inline const std::string& SatParameters_ClauseProtection_Name(T enum_t_value) {
184  static_assert(::std::is_same<T, SatParameters_ClauseProtection>::value ||
185  ::std::is_integral<T>::value,
186  "Incorrect type passed to function SatParameters_ClauseProtection_Name.");
187  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
188  SatParameters_ClauseProtection_descriptor(), enum_t_value);
189 }
190 inline bool SatParameters_ClauseProtection_Parse(
191  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ClauseProtection* value) {
192  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ClauseProtection>(
193  SatParameters_ClauseProtection_descriptor(), name, value);
194 }
195 enum SatParameters_ClauseOrdering : int {
196  SatParameters_ClauseOrdering_CLAUSE_ACTIVITY = 0,
197  SatParameters_ClauseOrdering_CLAUSE_LBD = 1
198 };
199 bool SatParameters_ClauseOrdering_IsValid(int value);
200 constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MIN = SatParameters_ClauseOrdering_CLAUSE_ACTIVITY;
201 constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MAX = SatParameters_ClauseOrdering_CLAUSE_LBD;
202 constexpr int SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE = SatParameters_ClauseOrdering_ClauseOrdering_MAX + 1;
203 
204 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ClauseOrdering_descriptor();
205 template<typename T>
206 inline const std::string& SatParameters_ClauseOrdering_Name(T enum_t_value) {
207  static_assert(::std::is_same<T, SatParameters_ClauseOrdering>::value ||
208  ::std::is_integral<T>::value,
209  "Incorrect type passed to function SatParameters_ClauseOrdering_Name.");
210  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
211  SatParameters_ClauseOrdering_descriptor(), enum_t_value);
212 }
213 inline bool SatParameters_ClauseOrdering_Parse(
214  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ClauseOrdering* value) {
215  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_ClauseOrdering>(
216  SatParameters_ClauseOrdering_descriptor(), name, value);
217 }
218 enum SatParameters_RestartAlgorithm : int {
219  SatParameters_RestartAlgorithm_NO_RESTART = 0,
220  SatParameters_RestartAlgorithm_LUBY_RESTART = 1,
221  SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART = 2,
222  SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART = 3,
223  SatParameters_RestartAlgorithm_FIXED_RESTART = 4
224 };
225 bool SatParameters_RestartAlgorithm_IsValid(int value);
226 constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MIN = SatParameters_RestartAlgorithm_NO_RESTART;
227 constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MAX = SatParameters_RestartAlgorithm_FIXED_RESTART;
228 constexpr int SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE = SatParameters_RestartAlgorithm_RestartAlgorithm_MAX + 1;
229 
230 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_RestartAlgorithm_descriptor();
231 template<typename T>
232 inline const std::string& SatParameters_RestartAlgorithm_Name(T enum_t_value) {
233  static_assert(::std::is_same<T, SatParameters_RestartAlgorithm>::value ||
234  ::std::is_integral<T>::value,
235  "Incorrect type passed to function SatParameters_RestartAlgorithm_Name.");
236  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
237  SatParameters_RestartAlgorithm_descriptor(), enum_t_value);
238 }
239 inline bool SatParameters_RestartAlgorithm_Parse(
240  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_RestartAlgorithm* value) {
241  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_RestartAlgorithm>(
242  SatParameters_RestartAlgorithm_descriptor(), name, value);
243 }
244 enum SatParameters_MaxSatAssumptionOrder : int {
245  SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER = 0,
246  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH = 1,
247  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT = 2
248 };
249 bool SatParameters_MaxSatAssumptionOrder_IsValid(int value);
250 constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN = SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER;
251 constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX = SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT;
252 constexpr int SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE = SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX + 1;
253 
254 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_MaxSatAssumptionOrder_descriptor();
255 template<typename T>
256 inline const std::string& SatParameters_MaxSatAssumptionOrder_Name(T enum_t_value) {
257  static_assert(::std::is_same<T, SatParameters_MaxSatAssumptionOrder>::value ||
258  ::std::is_integral<T>::value,
259  "Incorrect type passed to function SatParameters_MaxSatAssumptionOrder_Name.");
260  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
261  SatParameters_MaxSatAssumptionOrder_descriptor(), enum_t_value);
262 }
263 inline bool SatParameters_MaxSatAssumptionOrder_Parse(
264  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_MaxSatAssumptionOrder* value) {
265  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_MaxSatAssumptionOrder>(
266  SatParameters_MaxSatAssumptionOrder_descriptor(), name, value);
267 }
268 enum SatParameters_MaxSatStratificationAlgorithm : int {
269  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE = 0,
270  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT = 1,
271  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT = 2
272 };
273 bool SatParameters_MaxSatStratificationAlgorithm_IsValid(int value);
274 constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN = SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE;
275 constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX = SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT;
276 constexpr int SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE = SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX + 1;
277 
278 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_MaxSatStratificationAlgorithm_descriptor();
279 template<typename T>
280 inline const std::string& SatParameters_MaxSatStratificationAlgorithm_Name(T enum_t_value) {
281  static_assert(::std::is_same<T, SatParameters_MaxSatStratificationAlgorithm>::value ||
282  ::std::is_integral<T>::value,
283  "Incorrect type passed to function SatParameters_MaxSatStratificationAlgorithm_Name.");
284  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
285  SatParameters_MaxSatStratificationAlgorithm_descriptor(), enum_t_value);
286 }
287 inline bool SatParameters_MaxSatStratificationAlgorithm_Parse(
288  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_MaxSatStratificationAlgorithm* value) {
289  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_MaxSatStratificationAlgorithm>(
290  SatParameters_MaxSatStratificationAlgorithm_descriptor(), name, value);
291 }
292 enum SatParameters_SearchBranching : int {
293  SatParameters_SearchBranching_AUTOMATIC_SEARCH = 0,
294  SatParameters_SearchBranching_FIXED_SEARCH = 1,
295  SatParameters_SearchBranching_PORTFOLIO_SEARCH = 2,
296  SatParameters_SearchBranching_LP_SEARCH = 3,
297  SatParameters_SearchBranching_PSEUDO_COST_SEARCH = 4,
298  SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH = 5,
299  SatParameters_SearchBranching_HINT_SEARCH = 6
300 };
301 bool SatParameters_SearchBranching_IsValid(int value);
302 constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MIN = SatParameters_SearchBranching_AUTOMATIC_SEARCH;
303 constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MAX = SatParameters_SearchBranching_HINT_SEARCH;
304 constexpr int SatParameters_SearchBranching_SearchBranching_ARRAYSIZE = SatParameters_SearchBranching_SearchBranching_MAX + 1;
305 
306 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_SearchBranching_descriptor();
307 template<typename T>
308 inline const std::string& SatParameters_SearchBranching_Name(T enum_t_value) {
309  static_assert(::std::is_same<T, SatParameters_SearchBranching>::value ||
310  ::std::is_integral<T>::value,
311  "Incorrect type passed to function SatParameters_SearchBranching_Name.");
312  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
313  SatParameters_SearchBranching_descriptor(), enum_t_value);
314 }
315 inline bool SatParameters_SearchBranching_Parse(
316  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_SearchBranching* value) {
317  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_SearchBranching>(
318  SatParameters_SearchBranching_descriptor(), name, value);
319 }
320 enum SatParameters_FPRoundingMethod : int {
321  SatParameters_FPRoundingMethod_NEAREST_INTEGER = 0,
322  SatParameters_FPRoundingMethod_LOCK_BASED = 1,
323  SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED = 3,
324  SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED = 2
325 };
326 bool SatParameters_FPRoundingMethod_IsValid(int value);
327 constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MIN = SatParameters_FPRoundingMethod_NEAREST_INTEGER;
328 constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MAX = SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED;
329 constexpr int SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE = SatParameters_FPRoundingMethod_FPRoundingMethod_MAX + 1;
330 
331 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_FPRoundingMethod_descriptor();
332 template<typename T>
333 inline const std::string& SatParameters_FPRoundingMethod_Name(T enum_t_value) {
334  static_assert(::std::is_same<T, SatParameters_FPRoundingMethod>::value ||
335  ::std::is_integral<T>::value,
336  "Incorrect type passed to function SatParameters_FPRoundingMethod_Name.");
337  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
338  SatParameters_FPRoundingMethod_descriptor(), enum_t_value);
339 }
340 inline bool SatParameters_FPRoundingMethod_Parse(
341  ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_FPRoundingMethod* value) {
342  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SatParameters_FPRoundingMethod>(
343  SatParameters_FPRoundingMethod_descriptor(), name, value);
344 }
345 // ===================================================================
346 
347 class SatParameters PROTOBUF_FINAL :
348  public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:operations_research.sat.SatParameters) */ {
349  public:
350  inline SatParameters() : SatParameters(nullptr) {}
351  virtual ~SatParameters();
352 
353  SatParameters(const SatParameters& from);
354  SatParameters(SatParameters&& from) noexcept
355  : SatParameters() {
356  *this = ::std::move(from);
357  }
358 
359  inline SatParameters& operator=(const SatParameters& from) {
360  CopyFrom(from);
361  return *this;
362  }
363  inline SatParameters& operator=(SatParameters&& from) noexcept {
364  if (GetArena() == from.GetArena()) {
365  if (this != &from) InternalSwap(&from);
366  } else {
367  CopyFrom(from);
368  }
369  return *this;
370  }
371 
372  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
373  return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
374  }
375  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
376  return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
377  }
378 
379  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
380  return GetDescriptor();
381  }
382  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
383  return GetMetadataStatic().descriptor;
384  }
385  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
386  return GetMetadataStatic().reflection;
387  }
388  static const SatParameters& default_instance();
389 
390  static inline const SatParameters* internal_default_instance() {
391  return reinterpret_cast<const SatParameters*>(
392  &_SatParameters_default_instance_);
393  }
394  static constexpr int kIndexInFileMessages =
395  0;
396 
397  friend void swap(SatParameters& a, SatParameters& b) {
398  a.Swap(&b);
399  }
400  inline void Swap(SatParameters* other) {
401  if (other == this) return;
402  if (GetArena() == other->GetArena()) {
403  InternalSwap(other);
404  } else {
405  ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
406  }
407  }
408  void UnsafeArenaSwap(SatParameters* other) {
409  if (other == this) return;
410  GOOGLE_DCHECK(GetArena() == other->GetArena());
411  InternalSwap(other);
412  }
413 
414  // implements Message ----------------------------------------------
415 
416  inline SatParameters* New() const final {
417  return CreateMaybeMessage<SatParameters>(nullptr);
418  }
419 
420  SatParameters* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
421  return CreateMaybeMessage<SatParameters>(arena);
422  }
423  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
424  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
425  void CopyFrom(const SatParameters& from);
426  void MergeFrom(const SatParameters& from);
427  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
428  bool IsInitialized() const final;
429 
430  size_t ByteSizeLong() const final;
431  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
432  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
433  ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
434  int GetCachedSize() const final { return _cached_size_.Get(); }
435 
436  private:
437  inline void SharedCtor();
438  inline void SharedDtor();
439  void SetCachedSize(int size) const final;
440  void InternalSwap(SatParameters* other);
441  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
442  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
443  return "operations_research.sat.SatParameters";
444  }
445  protected:
446  explicit SatParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena);
447  private:
448  static void ArenaDtor(void* object);
449  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
450  public:
451 
452  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
453  private:
454  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
455  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
456  return ::descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto.file_level_metadata[kIndexInFileMessages];
457  }
458 
459  public:
460 
461  // nested types ----------------------------------------------------
462 
463  typedef SatParameters_VariableOrder VariableOrder;
464  static constexpr VariableOrder IN_ORDER =
465  SatParameters_VariableOrder_IN_ORDER;
466  static constexpr VariableOrder IN_REVERSE_ORDER =
467  SatParameters_VariableOrder_IN_REVERSE_ORDER;
468  static constexpr VariableOrder IN_RANDOM_ORDER =
469  SatParameters_VariableOrder_IN_RANDOM_ORDER;
470  static inline bool VariableOrder_IsValid(int value) {
471  return SatParameters_VariableOrder_IsValid(value);
472  }
473  static constexpr VariableOrder VariableOrder_MIN =
474  SatParameters_VariableOrder_VariableOrder_MIN;
475  static constexpr VariableOrder VariableOrder_MAX =
476  SatParameters_VariableOrder_VariableOrder_MAX;
477  static constexpr int VariableOrder_ARRAYSIZE =
478  SatParameters_VariableOrder_VariableOrder_ARRAYSIZE;
479  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
480  VariableOrder_descriptor() {
481  return SatParameters_VariableOrder_descriptor();
482  }
483  template<typename T>
484  static inline const std::string& VariableOrder_Name(T enum_t_value) {
485  static_assert(::std::is_same<T, VariableOrder>::value ||
486  ::std::is_integral<T>::value,
487  "Incorrect type passed to function VariableOrder_Name.");
488  return SatParameters_VariableOrder_Name(enum_t_value);
489  }
490  static inline bool VariableOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
491  VariableOrder* value) {
492  return SatParameters_VariableOrder_Parse(name, value);
493  }
494 
495  typedef SatParameters_Polarity Polarity;
496  static constexpr Polarity POLARITY_TRUE =
497  SatParameters_Polarity_POLARITY_TRUE;
498  static constexpr Polarity POLARITY_FALSE =
499  SatParameters_Polarity_POLARITY_FALSE;
500  static constexpr Polarity POLARITY_RANDOM =
501  SatParameters_Polarity_POLARITY_RANDOM;
502  static constexpr Polarity POLARITY_WEIGHTED_SIGN =
503  SatParameters_Polarity_POLARITY_WEIGHTED_SIGN;
504  static constexpr Polarity POLARITY_REVERSE_WEIGHTED_SIGN =
505  SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN;
506  static inline bool Polarity_IsValid(int value) {
507  return SatParameters_Polarity_IsValid(value);
508  }
509  static constexpr Polarity Polarity_MIN =
510  SatParameters_Polarity_Polarity_MIN;
511  static constexpr Polarity Polarity_MAX =
512  SatParameters_Polarity_Polarity_MAX;
513  static constexpr int Polarity_ARRAYSIZE =
514  SatParameters_Polarity_Polarity_ARRAYSIZE;
515  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
516  Polarity_descriptor() {
517  return SatParameters_Polarity_descriptor();
518  }
519  template<typename T>
520  static inline const std::string& Polarity_Name(T enum_t_value) {
521  static_assert(::std::is_same<T, Polarity>::value ||
522  ::std::is_integral<T>::value,
523  "Incorrect type passed to function Polarity_Name.");
524  return SatParameters_Polarity_Name(enum_t_value);
525  }
526  static inline bool Polarity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
527  Polarity* value) {
528  return SatParameters_Polarity_Parse(name, value);
529  }
530 
531  typedef SatParameters_ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm;
532  static constexpr ConflictMinimizationAlgorithm NONE =
533  SatParameters_ConflictMinimizationAlgorithm_NONE;
534  static constexpr ConflictMinimizationAlgorithm SIMPLE =
535  SatParameters_ConflictMinimizationAlgorithm_SIMPLE;
536  static constexpr ConflictMinimizationAlgorithm RECURSIVE =
537  SatParameters_ConflictMinimizationAlgorithm_RECURSIVE;
538  static constexpr ConflictMinimizationAlgorithm EXPERIMENTAL =
539  SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL;
540  static inline bool ConflictMinimizationAlgorithm_IsValid(int value) {
541  return SatParameters_ConflictMinimizationAlgorithm_IsValid(value);
542  }
543  static constexpr ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm_MIN =
544  SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN;
545  static constexpr ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm_MAX =
546  SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX;
547  static constexpr int ConflictMinimizationAlgorithm_ARRAYSIZE =
548  SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE;
549  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
550  ConflictMinimizationAlgorithm_descriptor() {
551  return SatParameters_ConflictMinimizationAlgorithm_descriptor();
552  }
553  template<typename T>
554  static inline const std::string& ConflictMinimizationAlgorithm_Name(T enum_t_value) {
555  static_assert(::std::is_same<T, ConflictMinimizationAlgorithm>::value ||
556  ::std::is_integral<T>::value,
557  "Incorrect type passed to function ConflictMinimizationAlgorithm_Name.");
558  return SatParameters_ConflictMinimizationAlgorithm_Name(enum_t_value);
559  }
560  static inline bool ConflictMinimizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
561  ConflictMinimizationAlgorithm* value) {
562  return SatParameters_ConflictMinimizationAlgorithm_Parse(name, value);
563  }
564 
565  typedef SatParameters_BinaryMinizationAlgorithm BinaryMinizationAlgorithm;
566  static constexpr BinaryMinizationAlgorithm NO_BINARY_MINIMIZATION =
567  SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION;
568  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_FIRST =
569  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST;
570  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION =
571  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION;
572  static constexpr BinaryMinizationAlgorithm BINARY_MINIMIZATION_WITH_REACHABILITY =
573  SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY;
574  static constexpr BinaryMinizationAlgorithm EXPERIMENTAL_BINARY_MINIMIZATION =
575  SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION;
576  static inline bool BinaryMinizationAlgorithm_IsValid(int value) {
577  return SatParameters_BinaryMinizationAlgorithm_IsValid(value);
578  }
579  static constexpr BinaryMinizationAlgorithm BinaryMinizationAlgorithm_MIN =
580  SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN;
581  static constexpr BinaryMinizationAlgorithm BinaryMinizationAlgorithm_MAX =
582  SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX;
583  static constexpr int BinaryMinizationAlgorithm_ARRAYSIZE =
584  SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE;
585  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
586  BinaryMinizationAlgorithm_descriptor() {
587  return SatParameters_BinaryMinizationAlgorithm_descriptor();
588  }
589  template<typename T>
590  static inline const std::string& BinaryMinizationAlgorithm_Name(T enum_t_value) {
591  static_assert(::std::is_same<T, BinaryMinizationAlgorithm>::value ||
592  ::std::is_integral<T>::value,
593  "Incorrect type passed to function BinaryMinizationAlgorithm_Name.");
594  return SatParameters_BinaryMinizationAlgorithm_Name(enum_t_value);
595  }
596  static inline bool BinaryMinizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
597  BinaryMinizationAlgorithm* value) {
598  return SatParameters_BinaryMinizationAlgorithm_Parse(name, value);
599  }
600 
601  typedef SatParameters_ClauseProtection ClauseProtection;
602  static constexpr ClauseProtection PROTECTION_NONE =
603  SatParameters_ClauseProtection_PROTECTION_NONE;
604  static constexpr ClauseProtection PROTECTION_ALWAYS =
605  SatParameters_ClauseProtection_PROTECTION_ALWAYS;
606  static constexpr ClauseProtection PROTECTION_LBD =
607  SatParameters_ClauseProtection_PROTECTION_LBD;
608  static inline bool ClauseProtection_IsValid(int value) {
609  return SatParameters_ClauseProtection_IsValid(value);
610  }
611  static constexpr ClauseProtection ClauseProtection_MIN =
612  SatParameters_ClauseProtection_ClauseProtection_MIN;
613  static constexpr ClauseProtection ClauseProtection_MAX =
614  SatParameters_ClauseProtection_ClauseProtection_MAX;
615  static constexpr int ClauseProtection_ARRAYSIZE =
616  SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE;
617  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
618  ClauseProtection_descriptor() {
619  return SatParameters_ClauseProtection_descriptor();
620  }
621  template<typename T>
622  static inline const std::string& ClauseProtection_Name(T enum_t_value) {
623  static_assert(::std::is_same<T, ClauseProtection>::value ||
624  ::std::is_integral<T>::value,
625  "Incorrect type passed to function ClauseProtection_Name.");
626  return SatParameters_ClauseProtection_Name(enum_t_value);
627  }
628  static inline bool ClauseProtection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
629  ClauseProtection* value) {
630  return SatParameters_ClauseProtection_Parse(name, value);
631  }
632 
633  typedef SatParameters_ClauseOrdering ClauseOrdering;
634  static constexpr ClauseOrdering CLAUSE_ACTIVITY =
635  SatParameters_ClauseOrdering_CLAUSE_ACTIVITY;
636  static constexpr ClauseOrdering CLAUSE_LBD =
637  SatParameters_ClauseOrdering_CLAUSE_LBD;
638  static inline bool ClauseOrdering_IsValid(int value) {
639  return SatParameters_ClauseOrdering_IsValid(value);
640  }
641  static constexpr ClauseOrdering ClauseOrdering_MIN =
642  SatParameters_ClauseOrdering_ClauseOrdering_MIN;
643  static constexpr ClauseOrdering ClauseOrdering_MAX =
644  SatParameters_ClauseOrdering_ClauseOrdering_MAX;
645  static constexpr int ClauseOrdering_ARRAYSIZE =
646  SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE;
647  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
648  ClauseOrdering_descriptor() {
649  return SatParameters_ClauseOrdering_descriptor();
650  }
651  template<typename T>
652  static inline const std::string& ClauseOrdering_Name(T enum_t_value) {
653  static_assert(::std::is_same<T, ClauseOrdering>::value ||
654  ::std::is_integral<T>::value,
655  "Incorrect type passed to function ClauseOrdering_Name.");
656  return SatParameters_ClauseOrdering_Name(enum_t_value);
657  }
658  static inline bool ClauseOrdering_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
659  ClauseOrdering* value) {
660  return SatParameters_ClauseOrdering_Parse(name, value);
661  }
662 
663  typedef SatParameters_RestartAlgorithm RestartAlgorithm;
664  static constexpr RestartAlgorithm NO_RESTART =
665  SatParameters_RestartAlgorithm_NO_RESTART;
666  static constexpr RestartAlgorithm LUBY_RESTART =
667  SatParameters_RestartAlgorithm_LUBY_RESTART;
668  static constexpr RestartAlgorithm DL_MOVING_AVERAGE_RESTART =
669  SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART;
670  static constexpr RestartAlgorithm LBD_MOVING_AVERAGE_RESTART =
671  SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART;
672  static constexpr RestartAlgorithm FIXED_RESTART =
673  SatParameters_RestartAlgorithm_FIXED_RESTART;
674  static inline bool RestartAlgorithm_IsValid(int value) {
675  return SatParameters_RestartAlgorithm_IsValid(value);
676  }
677  static constexpr RestartAlgorithm RestartAlgorithm_MIN =
678  SatParameters_RestartAlgorithm_RestartAlgorithm_MIN;
679  static constexpr RestartAlgorithm RestartAlgorithm_MAX =
680  SatParameters_RestartAlgorithm_RestartAlgorithm_MAX;
681  static constexpr int RestartAlgorithm_ARRAYSIZE =
682  SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE;
683  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
684  RestartAlgorithm_descriptor() {
685  return SatParameters_RestartAlgorithm_descriptor();
686  }
687  template<typename T>
688  static inline const std::string& RestartAlgorithm_Name(T enum_t_value) {
689  static_assert(::std::is_same<T, RestartAlgorithm>::value ||
690  ::std::is_integral<T>::value,
691  "Incorrect type passed to function RestartAlgorithm_Name.");
692  return SatParameters_RestartAlgorithm_Name(enum_t_value);
693  }
694  static inline bool RestartAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
695  RestartAlgorithm* value) {
696  return SatParameters_RestartAlgorithm_Parse(name, value);
697  }
698 
699  typedef SatParameters_MaxSatAssumptionOrder MaxSatAssumptionOrder;
700  static constexpr MaxSatAssumptionOrder DEFAULT_ASSUMPTION_ORDER =
701  SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER;
702  static constexpr MaxSatAssumptionOrder ORDER_ASSUMPTION_BY_DEPTH =
703  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH;
704  static constexpr MaxSatAssumptionOrder ORDER_ASSUMPTION_BY_WEIGHT =
705  SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT;
706  static inline bool MaxSatAssumptionOrder_IsValid(int value) {
707  return SatParameters_MaxSatAssumptionOrder_IsValid(value);
708  }
709  static constexpr MaxSatAssumptionOrder MaxSatAssumptionOrder_MIN =
710  SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN;
711  static constexpr MaxSatAssumptionOrder MaxSatAssumptionOrder_MAX =
712  SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX;
713  static constexpr int MaxSatAssumptionOrder_ARRAYSIZE =
714  SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE;
715  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
716  MaxSatAssumptionOrder_descriptor() {
717  return SatParameters_MaxSatAssumptionOrder_descriptor();
718  }
719  template<typename T>
720  static inline const std::string& MaxSatAssumptionOrder_Name(T enum_t_value) {
721  static_assert(::std::is_same<T, MaxSatAssumptionOrder>::value ||
722  ::std::is_integral<T>::value,
723  "Incorrect type passed to function MaxSatAssumptionOrder_Name.");
724  return SatParameters_MaxSatAssumptionOrder_Name(enum_t_value);
725  }
726  static inline bool MaxSatAssumptionOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
727  MaxSatAssumptionOrder* value) {
728  return SatParameters_MaxSatAssumptionOrder_Parse(name, value);
729  }
730 
731  typedef SatParameters_MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm;
732  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_NONE =
733  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE;
734  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_DESCENT =
735  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT;
736  static constexpr MaxSatStratificationAlgorithm STRATIFICATION_ASCENT =
737  SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT;
738  static inline bool MaxSatStratificationAlgorithm_IsValid(int value) {
739  return SatParameters_MaxSatStratificationAlgorithm_IsValid(value);
740  }
741  static constexpr MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm_MIN =
742  SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN;
743  static constexpr MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm_MAX =
744  SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX;
745  static constexpr int MaxSatStratificationAlgorithm_ARRAYSIZE =
746  SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE;
747  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
748  MaxSatStratificationAlgorithm_descriptor() {
749  return SatParameters_MaxSatStratificationAlgorithm_descriptor();
750  }
751  template<typename T>
752  static inline const std::string& MaxSatStratificationAlgorithm_Name(T enum_t_value) {
753  static_assert(::std::is_same<T, MaxSatStratificationAlgorithm>::value ||
754  ::std::is_integral<T>::value,
755  "Incorrect type passed to function MaxSatStratificationAlgorithm_Name.");
756  return SatParameters_MaxSatStratificationAlgorithm_Name(enum_t_value);
757  }
758  static inline bool MaxSatStratificationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
759  MaxSatStratificationAlgorithm* value) {
760  return SatParameters_MaxSatStratificationAlgorithm_Parse(name, value);
761  }
762 
763  typedef SatParameters_SearchBranching SearchBranching;
764  static constexpr SearchBranching AUTOMATIC_SEARCH =
765  SatParameters_SearchBranching_AUTOMATIC_SEARCH;
766  static constexpr SearchBranching FIXED_SEARCH =
767  SatParameters_SearchBranching_FIXED_SEARCH;
768  static constexpr SearchBranching PORTFOLIO_SEARCH =
769  SatParameters_SearchBranching_PORTFOLIO_SEARCH;
770  static constexpr SearchBranching LP_SEARCH =
771  SatParameters_SearchBranching_LP_SEARCH;
772  static constexpr SearchBranching PSEUDO_COST_SEARCH =
773  SatParameters_SearchBranching_PSEUDO_COST_SEARCH;
774  static constexpr SearchBranching PORTFOLIO_WITH_QUICK_RESTART_SEARCH =
775  SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH;
776  static constexpr SearchBranching HINT_SEARCH =
777  SatParameters_SearchBranching_HINT_SEARCH;
778  static inline bool SearchBranching_IsValid(int value) {
779  return SatParameters_SearchBranching_IsValid(value);
780  }
781  static constexpr SearchBranching SearchBranching_MIN =
782  SatParameters_SearchBranching_SearchBranching_MIN;
783  static constexpr SearchBranching SearchBranching_MAX =
784  SatParameters_SearchBranching_SearchBranching_MAX;
785  static constexpr int SearchBranching_ARRAYSIZE =
786  SatParameters_SearchBranching_SearchBranching_ARRAYSIZE;
787  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
788  SearchBranching_descriptor() {
789  return SatParameters_SearchBranching_descriptor();
790  }
791  template<typename T>
792  static inline const std::string& SearchBranching_Name(T enum_t_value) {
793  static_assert(::std::is_same<T, SearchBranching>::value ||
794  ::std::is_integral<T>::value,
795  "Incorrect type passed to function SearchBranching_Name.");
796  return SatParameters_SearchBranching_Name(enum_t_value);
797  }
798  static inline bool SearchBranching_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
799  SearchBranching* value) {
800  return SatParameters_SearchBranching_Parse(name, value);
801  }
802 
803  typedef SatParameters_FPRoundingMethod FPRoundingMethod;
804  static constexpr FPRoundingMethod NEAREST_INTEGER =
805  SatParameters_FPRoundingMethod_NEAREST_INTEGER;
806  static constexpr FPRoundingMethod LOCK_BASED =
807  SatParameters_FPRoundingMethod_LOCK_BASED;
808  static constexpr FPRoundingMethod ACTIVE_LOCK_BASED =
809  SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED;
810  static constexpr FPRoundingMethod PROPAGATION_ASSISTED =
811  SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED;
812  static inline bool FPRoundingMethod_IsValid(int value) {
813  return SatParameters_FPRoundingMethod_IsValid(value);
814  }
815  static constexpr FPRoundingMethod FPRoundingMethod_MIN =
816  SatParameters_FPRoundingMethod_FPRoundingMethod_MIN;
817  static constexpr FPRoundingMethod FPRoundingMethod_MAX =
818  SatParameters_FPRoundingMethod_FPRoundingMethod_MAX;
819  static constexpr int FPRoundingMethod_ARRAYSIZE =
820  SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE;
821  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
822  FPRoundingMethod_descriptor() {
823  return SatParameters_FPRoundingMethod_descriptor();
824  }
825  template<typename T>
826  static inline const std::string& FPRoundingMethod_Name(T enum_t_value) {
827  static_assert(::std::is_same<T, FPRoundingMethod>::value ||
828  ::std::is_integral<T>::value,
829  "Incorrect type passed to function FPRoundingMethod_Name.");
830  return SatParameters_FPRoundingMethod_Name(enum_t_value);
831  }
832  static inline bool FPRoundingMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
833  FPRoundingMethod* value) {
834  return SatParameters_FPRoundingMethod_Parse(name, value);
835  }
836 
837  // accessors -------------------------------------------------------
838 
839  enum : int {
840  kRestartAlgorithmsFieldNumber = 61,
841  kDefaultRestartAlgorithmsFieldNumber = 70,
842  kNameFieldNumber = 171,
843  kPreferredVariableOrderFieldNumber = 1,
844  kMaxSatAssumptionOrderFieldNumber = 51,
845  kRandomBranchesRatioFieldNumber = 32,
846  kRandomPolarityRatioFieldNumber = 45,
847  kClauseCleanupProtectionFieldNumber = 58,
848  kClauseCleanupOrderingFieldNumber = 60,
849  kStrategyChangeIncreaseRatioFieldNumber = 69,
850  kNumConflictsBeforeStrategyChangesFieldNumber = 68,
851  kSearchBranchingFieldNumber = 82,
852  kInitialVariablesActivityFieldNumber = 76,
853  kUseOverloadCheckerInCumulativeConstraintFieldNumber = 78,
854  kUseTimetableEdgeFindingInCumulativeConstraintFieldNumber = 79,
855  kOnlyAddCutsAtLevelZeroFieldNumber = 92,
856  kAddKnapsackCutsFieldNumber = 111,
857  kUseErwaHeuristicFieldNumber = 75,
858  kAlsoBumpVariablesInConflictReasonsFieldNumber = 77,
859  kUseBlockingRestartFieldNumber = 64,
860  kPermuteVariableRandomlyFieldNumber = 178,
861  kSearchRandomizationToleranceFieldNumber = 104,
862  kUsePbResolutionFieldNumber = 43,
863  kMinimizeReductionDuringPbResolutionFieldNumber = 48,
864  kCpModelPostsolveWithFullSolverFieldNumber = 162,
865  kUseSatInprocessingFieldNumber = 163,
866  kOptimizeWithCoreFieldNumber = 83,
867  kOptimizeWithMaxHsFieldNumber = 85,
868  kEnumerateAllSolutionsFieldNumber = 87,
869  kKeepAllFeasibleSolutionsInPresolveFieldNumber = 173,
870  kReduceMemoryUsageInInterleaveModeFieldNumber = 141,
871  kUseLnsOnlyFieldNumber = 101,
872  kLnsFocusOnDecisionVariablesFieldNumber = 105,
873  kUseRelaxationLnsFieldNumber = 150,
874  kDiversifyLnsParamsFieldNumber = 137,
875  kRandomizeSearchFieldNumber = 103,
876  kUseBranchingInLpFieldNumber = 139,
877  kUseCombinedNoOverlapFieldNumber = 133,
878  kFillTightenedDomainsInResponseFieldNumber = 132,
879  kStopAfterFirstSolutionFieldNumber = 98,
880  kStopAfterPresolveFieldNumber = 149,
881  kInterleaveSearchFieldNumber = 136,
882  kExpandAlldiffConstraintsFieldNumber = 170,
883  kDisableConstraintExpansionFieldNumber = 181,
884  kPresolveExtractIntegerEnforcementFieldNumber = 174,
885  kMaxSatReverseAssumptionOrderFieldNumber = 52,
886  kProbingPeriodAtRootFieldNumber = 142,
887  kPermutePresolveConstraintOrderFieldNumber = 179,
888  kUseAbslRandomFieldNumber = 180,
889  kLogSearchProgressFieldNumber = 41,
890  kFillLogsInResponseFieldNumber = 185,
891  kCpModelMaxNumPresolveOperationsFieldNumber = 151,
892  kAbsoluteGapLimitFieldNumber = 159,
893  kRelativeGapLimitFieldNumber = 160,
894  kRepairHintFieldNumber = 167,
895  kExploitBestSolutionFieldNumber = 130,
896  kExploitRelaxationSolutionFieldNumber = 161,
897  kUseProbingSearchFieldNumber = 176,
898  kPolishLpSolutionFieldNumber = 175,
899  kConvertIntervalsFieldNumber = 177,
900  kInitialPolarityFieldNumber = 2,
901  kMinimizationAlgorithmFieldNumber = 4,
902  kClauseCleanupPeriodFieldNumber = 11,
903  kClauseCleanupTargetFieldNumber = 13,
904  kVariableActivityDecayFieldNumber = 15,
905  kMaxVariableActivityValueFieldNumber = 16,
906  kClauseActivityDecayFieldNumber = 17,
907  kMaxClauseActivityValueFieldNumber = 18,
908  kGlucoseMaxDecayFieldNumber = 22,
909  kGlucoseDecayIncrementFieldNumber = 23,
910  kGlucoseDecayIncrementPeriodFieldNumber = 24,
911  kRestartPeriodFieldNumber = 30,
912  kRandomSeedFieldNumber = 31,
913  kBinaryMinimizationAlgorithmFieldNumber = 34,
914  kMaxTimeInSecondsFieldNumber = 36,
915  kMaxNumberOfConflictsFieldNumber = 37,
916  kMaxMemoryInMbFieldNumber = 40,
917  kUsePhaseSavingFieldNumber = 44,
918  kSubsumptionDuringConflictAnalysisFieldNumber = 56,
919  kTreatBinaryClausesSeparatelyFieldNumber = 33,
920  kCountAssumptionLevelsInLbdFieldNumber = 49,
921  kPbCleanupIncrementFieldNumber = 46,
922  kPbCleanupRatioFieldNumber = 47,
923  kMaxSatStratificationFieldNumber = 53,
924  kPresolveBveThresholdFieldNumber = 54,
925  kPresolveProbingDeterministicTimeLimitFieldNumber = 57,
926  kPresolveBveClauseWeightFieldNumber = 55,
927  kClauseCleanupLbdBoundFieldNumber = 59,
928  kRestartDlAverageRatioFieldNumber = 63,
929  kRestartRunningWindowSizeFieldNumber = 62,
930  kUseOptimizationHintsFieldNumber = 35,
931  kMinimizeCoreFieldNumber = 50,
932  kFindMultipleCoresFieldNumber = 84,
933  kCoverOptimizationFieldNumber = 89,
934  kBlockingRestartMultiplierFieldNumber = 66,
935  kMaxDeterministicTimeFieldNumber = 67,
936  kBlockingRestartWindowSizeFieldNumber = 65,
937  kPresolveBvaThresholdFieldNumber = 73,
938  kRestartLbdAverageRatioFieldNumber = 71,
939  kPresolveBlockedClauseFieldNumber = 88,
940  kPresolveUseBvaFieldNumber = 72,
941  kCpModelPresolveFieldNumber = 86,
942  kCpModelUseSatPresolveFieldNumber = 93,
943  kLinearizationLevelFieldNumber = 90,
944  kMaxNumCutsFieldNumber = 91,
945  kMinimizeWithPropagationRestartPeriodFieldNumber = 96,
946  kMinimizeWithPropagationNumDecisionsFieldNumber = 97,
947  kUsePrecedencesInDisjunctiveConstraintFieldNumber = 74,
948  kUseDisjunctiveConstraintInCumulativeConstraintFieldNumber = 80,
949  kAddCgCutsFieldNumber = 117,
950  kAddMirCutsFieldNumber = 120,
951  kBinarySearchNumConflictsFieldNumber = 99,
952  kNumSearchWorkersFieldNumber = 100,
953  kBooleanEncodingLevelFieldNumber = 107,
954  kCpModelProbingLevelFieldNumber = 110,
955  kExploitIntegerLpSolutionFieldNumber = 94,
956  kExploitAllLpSolutionFieldNumber = 116,
957  kExploitObjectiveFieldNumber = 131,
958  kInstantiateAllVariablesFieldNumber = 106,
959  kMaxIntegerRoundingScalingFieldNumber = 119,
960  kMinOrthogonalityForLpConstraintsFieldNumber = 115,
961  kMaxConsecutiveInactiveCountFieldNumber = 121,
962  kNewConstraintsBatchSizeFieldNumber = 122,
963  kPseudoCostReliabilityThresholdFieldNumber = 123,
964  kMipMaxBoundFieldNumber = 124,
965  kMipVarScalingFieldNumber = 125,
966  kMipWantedPrecisionFieldNumber = 126,
967  kAutoDetectGreaterThanAtLeastOneOfFieldNumber = 95,
968  kShareObjectiveBoundsFieldNumber = 113,
969  kShareLevelZeroBoundsFieldNumber = 114,
970  kLnsExpandIntervalsInConstraintGraphFieldNumber = 184,
971  kMipMaxActivityExponentFieldNumber = 127,
972  kMipCheckPrecisionFieldNumber = 128,
973  kUseRinsLnsFieldNumber = 129,
974  kUseFeasibilityPumpFieldNumber = 164,
975  kUseOptionalVariablesFieldNumber = 108,
976  kUseExactLpReasonFieldNumber = 109,
977  kInterleaveBatchSizeFieldNumber = 134,
978  kMaxPresolveIterationsFieldNumber = 138,
979  kPresolveSubstitutionLevelFieldNumber = 147,
980  kMergeNoOverlapWorkLimitFieldNumber = 145,
981  kMergeAtMostOneWorkLimitFieldNumber = 146,
982  kMaxAllDiffCutSizeFieldNumber = 148,
983  kCatchSigintSignalFieldNumber = 135,
984  kUseImpliedBoundsFieldNumber = 144,
985  kMipAutomaticallyScaleVariablesFieldNumber = 166,
986  kAddZeroHalfCutsFieldNumber = 169,
987  kAddCliqueCutsFieldNumber = 172,
988  kAddLinMaxCutsFieldNumber = 152,
989  kAddLpConstraintsLazilyFieldNumber = 112,
990  kHintConflictLimitFieldNumber = 153,
991  kCutMaxActiveCountValueFieldNumber = 155,
992  kMaxCutRoundsAtLevelZeroFieldNumber = 154,
993  kExpandElementConstraintsFieldNumber = 140,
994  kExpandAutomatonConstraintsFieldNumber = 143,
995  kExpandTableConstraintsFieldNumber = 158,
996  kExpandReservoirConstraintsFieldNumber = 182,
997  kCutActiveCountDecayFieldNumber = 156,
998  kCutCleanupTargetFieldNumber = 157,
999  kFpRoundingFieldNumber = 165,
1000  kPolarityRephaseIncrementFieldNumber = 168,
1001  kSymmetryLevelFieldNumber = 183,
1002  };
1003  // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
1004  int restart_algorithms_size() const;
1005  private:
1006  int _internal_restart_algorithms_size() const;
1007  public:
1008  void clear_restart_algorithms();
1009  private:
1010  ::operations_research::sat::SatParameters_RestartAlgorithm _internal_restart_algorithms(int index) const;
1011  void _internal_add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value);
1012  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_restart_algorithms();
1013  public:
1014  ::operations_research::sat::SatParameters_RestartAlgorithm restart_algorithms(int index) const;
1015  void set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value);
1016  void add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value);
1017  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& restart_algorithms() const;
1018  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_restart_algorithms();
1019 
1020  // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
1021  bool has_default_restart_algorithms() const;
1022  private:
1023  bool _internal_has_default_restart_algorithms() const;
1024  public:
1025  void clear_default_restart_algorithms();
1026  const std::string& default_restart_algorithms() const;
1027  void set_default_restart_algorithms(const std::string& value);
1028  void set_default_restart_algorithms(std::string&& value);
1029  void set_default_restart_algorithms(const char* value);
1030  void set_default_restart_algorithms(const char* value, size_t size);
1031  std::string* mutable_default_restart_algorithms();
1032  std::string* release_default_restart_algorithms();
1033  void set_allocated_default_restart_algorithms(std::string* default_restart_algorithms);
1034  private:
1035  const std::string& _internal_default_restart_algorithms() const;
1036  void _internal_set_default_restart_algorithms(const std::string& value);
1037  std::string* _internal_mutable_default_restart_algorithms();
1038  public:
1039 
1040  // optional string name = 171 [default = ""];
1041  bool has_name() const;
1042  private:
1043  bool _internal_has_name() const;
1044  public:
1045  void clear_name();
1046  const std::string& name() const;
1047  void set_name(const std::string& value);
1048  void set_name(std::string&& value);
1049  void set_name(const char* value);
1050  void set_name(const char* value, size_t size);
1051  std::string* mutable_name();
1052  std::string* release_name();
1053  void set_allocated_name(std::string* name);
1054  private:
1055  const std::string& _internal_name() const;
1056  void _internal_set_name(const std::string& value);
1057  std::string* _internal_mutable_name();
1058  public:
1059 
1060  // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
1061  bool has_preferred_variable_order() const;
1062  private:
1063  bool _internal_has_preferred_variable_order() const;
1064  public:
1065  void clear_preferred_variable_order();
1066  ::operations_research::sat::SatParameters_VariableOrder preferred_variable_order() const;
1067  void set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value);
1068  private:
1069  ::operations_research::sat::SatParameters_VariableOrder _internal_preferred_variable_order() const;
1070  void _internal_set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value);
1071  public:
1072 
1073  // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
1074  bool has_max_sat_assumption_order() const;
1075  private:
1076  bool _internal_has_max_sat_assumption_order() const;
1077  public:
1078  void clear_max_sat_assumption_order();
1079  ::operations_research::sat::SatParameters_MaxSatAssumptionOrder max_sat_assumption_order() const;
1080  void set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value);
1081  private:
1082  ::operations_research::sat::SatParameters_MaxSatAssumptionOrder _internal_max_sat_assumption_order() const;
1083  void _internal_set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value);
1084  public:
1085 
1086  // optional double random_branches_ratio = 32 [default = 0];
1087  bool has_random_branches_ratio() const;
1088  private:
1089  bool _internal_has_random_branches_ratio() const;
1090  public:
1091  void clear_random_branches_ratio();
1092  double random_branches_ratio() const;
1093  void set_random_branches_ratio(double value);
1094  private:
1095  double _internal_random_branches_ratio() const;
1096  void _internal_set_random_branches_ratio(double value);
1097  public:
1098 
1099  // optional double random_polarity_ratio = 45 [default = 0];
1100  bool has_random_polarity_ratio() const;
1101  private:
1102  bool _internal_has_random_polarity_ratio() const;
1103  public:
1104  void clear_random_polarity_ratio();
1105  double random_polarity_ratio() const;
1106  void set_random_polarity_ratio(double value);
1107  private:
1108  double _internal_random_polarity_ratio() const;
1109  void _internal_set_random_polarity_ratio(double value);
1110  public:
1111 
1112  // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
1113  bool has_clause_cleanup_protection() const;
1114  private:
1115  bool _internal_has_clause_cleanup_protection() const;
1116  public:
1117  void clear_clause_cleanup_protection();
1118  ::operations_research::sat::SatParameters_ClauseProtection clause_cleanup_protection() const;
1119  void set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value);
1120  private:
1121  ::operations_research::sat::SatParameters_ClauseProtection _internal_clause_cleanup_protection() const;
1122  void _internal_set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value);
1123  public:
1124 
1125  // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
1126  bool has_clause_cleanup_ordering() const;
1127  private:
1128  bool _internal_has_clause_cleanup_ordering() const;
1129  public:
1130  void clear_clause_cleanup_ordering();
1131  ::operations_research::sat::SatParameters_ClauseOrdering clause_cleanup_ordering() const;
1132  void set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value);
1133  private:
1134  ::operations_research::sat::SatParameters_ClauseOrdering _internal_clause_cleanup_ordering() const;
1135  void _internal_set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value);
1136  public:
1137 
1138  // optional double strategy_change_increase_ratio = 69 [default = 0];
1139  bool has_strategy_change_increase_ratio() const;
1140  private:
1141  bool _internal_has_strategy_change_increase_ratio() const;
1142  public:
1143  void clear_strategy_change_increase_ratio();
1144  double strategy_change_increase_ratio() const;
1145  void set_strategy_change_increase_ratio(double value);
1146  private:
1147  double _internal_strategy_change_increase_ratio() const;
1148  void _internal_set_strategy_change_increase_ratio(double value);
1149  public:
1150 
1151  // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
1152  bool has_num_conflicts_before_strategy_changes() const;
1153  private:
1154  bool _internal_has_num_conflicts_before_strategy_changes() const;
1155  public:
1156  void clear_num_conflicts_before_strategy_changes();
1157  ::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes() const;
1158  void set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value);
1159  private:
1160  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_conflicts_before_strategy_changes() const;
1161  void _internal_set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value);
1162  public:
1163 
1164  // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
1165  bool has_search_branching() const;
1166  private:
1167  bool _internal_has_search_branching() const;
1168  public:
1169  void clear_search_branching();
1170  ::operations_research::sat::SatParameters_SearchBranching search_branching() const;
1171  void set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);
1172  private:
1173  ::operations_research::sat::SatParameters_SearchBranching _internal_search_branching() const;
1174  void _internal_set_search_branching(::operations_research::sat::SatParameters_SearchBranching value);
1175  public:
1176 
1177  // optional double initial_variables_activity = 76 [default = 0];
1178  bool has_initial_variables_activity() const;
1179  private:
1180  bool _internal_has_initial_variables_activity() const;
1181  public:
1182  void clear_initial_variables_activity();
1183  double initial_variables_activity() const;
1184  void set_initial_variables_activity(double value);
1185  private:
1186  double _internal_initial_variables_activity() const;
1187  void _internal_set_initial_variables_activity(double value);
1188  public:
1189 
1190  // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
1191  bool has_use_overload_checker_in_cumulative_constraint() const;
1192  private:
1193  bool _internal_has_use_overload_checker_in_cumulative_constraint() const;
1194  public:
1195  void clear_use_overload_checker_in_cumulative_constraint();
1196  bool use_overload_checker_in_cumulative_constraint() const;
1197  void set_use_overload_checker_in_cumulative_constraint(bool value);
1198  private:
1199  bool _internal_use_overload_checker_in_cumulative_constraint() const;
1200  void _internal_set_use_overload_checker_in_cumulative_constraint(bool value);
1201  public:
1202 
1203  // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
1204  bool has_use_timetable_edge_finding_in_cumulative_constraint() const;
1205  private:
1206  bool _internal_has_use_timetable_edge_finding_in_cumulative_constraint() const;
1207  public:
1208  void clear_use_timetable_edge_finding_in_cumulative_constraint();
1209  bool use_timetable_edge_finding_in_cumulative_constraint() const;
1210  void set_use_timetable_edge_finding_in_cumulative_constraint(bool value);
1211  private:
1212  bool _internal_use_timetable_edge_finding_in_cumulative_constraint() const;
1213  void _internal_set_use_timetable_edge_finding_in_cumulative_constraint(bool value);
1214  public:
1215 
1216  // optional bool only_add_cuts_at_level_zero = 92 [default = false];
1217  bool has_only_add_cuts_at_level_zero() const;
1218  private:
1219  bool _internal_has_only_add_cuts_at_level_zero() const;
1220  public:
1221  void clear_only_add_cuts_at_level_zero();
1222  bool only_add_cuts_at_level_zero() const;
1223  void set_only_add_cuts_at_level_zero(bool value);
1224  private:
1225  bool _internal_only_add_cuts_at_level_zero() const;
1226  void _internal_set_only_add_cuts_at_level_zero(bool value);
1227  public:
1228 
1229  // optional bool add_knapsack_cuts = 111 [default = false];
1230  bool has_add_knapsack_cuts() const;
1231  private:
1232  bool _internal_has_add_knapsack_cuts() const;
1233  public:
1234  void clear_add_knapsack_cuts();
1235  bool add_knapsack_cuts() const;
1236  void set_add_knapsack_cuts(bool value);
1237  private:
1238  bool _internal_add_knapsack_cuts() const;
1239  void _internal_set_add_knapsack_cuts(bool value);
1240  public:
1241 
1242  // optional bool use_erwa_heuristic = 75 [default = false];
1243  bool has_use_erwa_heuristic() const;
1244  private:
1245  bool _internal_has_use_erwa_heuristic() const;
1246  public:
1247  void clear_use_erwa_heuristic();
1248  bool use_erwa_heuristic() const;
1249  void set_use_erwa_heuristic(bool value);
1250  private:
1251  bool _internal_use_erwa_heuristic() const;
1252  void _internal_set_use_erwa_heuristic(bool value);
1253  public:
1254 
1255  // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
1256  bool has_also_bump_variables_in_conflict_reasons() const;
1257  private:
1258  bool _internal_has_also_bump_variables_in_conflict_reasons() const;
1259  public:
1260  void clear_also_bump_variables_in_conflict_reasons();
1261  bool also_bump_variables_in_conflict_reasons() const;
1262  void set_also_bump_variables_in_conflict_reasons(bool value);
1263  private:
1264  bool _internal_also_bump_variables_in_conflict_reasons() const;
1265  void _internal_set_also_bump_variables_in_conflict_reasons(bool value);
1266  public:
1267 
1268  // optional bool use_blocking_restart = 64 [default = false];
1269  bool has_use_blocking_restart() const;
1270  private:
1271  bool _internal_has_use_blocking_restart() const;
1272  public:
1273  void clear_use_blocking_restart();
1274  bool use_blocking_restart() const;
1275  void set_use_blocking_restart(bool value);
1276  private:
1277  bool _internal_use_blocking_restart() const;
1278  void _internal_set_use_blocking_restart(bool value);
1279  public:
1280 
1281  // optional bool permute_variable_randomly = 178 [default = false];
1282  bool has_permute_variable_randomly() const;
1283  private:
1284  bool _internal_has_permute_variable_randomly() const;
1285  public:
1286  void clear_permute_variable_randomly();
1287  bool permute_variable_randomly() const;
1288  void set_permute_variable_randomly(bool value);
1289  private:
1290  bool _internal_permute_variable_randomly() const;
1291  void _internal_set_permute_variable_randomly(bool value);
1292  public:
1293 
1294  // optional int64 search_randomization_tolerance = 104 [default = 0];
1295  bool has_search_randomization_tolerance() const;
1296  private:
1297  bool _internal_has_search_randomization_tolerance() const;
1298  public:
1299  void clear_search_randomization_tolerance();
1300  ::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance() const;
1301  void set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value);
1302  private:
1303  ::PROTOBUF_NAMESPACE_ID::int64 _internal_search_randomization_tolerance() const;
1304  void _internal_set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value);
1305  public:
1306 
1307  // optional bool use_pb_resolution = 43 [default = false];
1308  bool has_use_pb_resolution() const;
1309  private:
1310  bool _internal_has_use_pb_resolution() const;
1311  public:
1312  void clear_use_pb_resolution();
1313  bool use_pb_resolution() const;
1314  void set_use_pb_resolution(bool value);
1315  private:
1316  bool _internal_use_pb_resolution() const;
1317  void _internal_set_use_pb_resolution(bool value);
1318  public:
1319 
1320  // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
1321  bool has_minimize_reduction_during_pb_resolution() const;
1322  private:
1323  bool _internal_has_minimize_reduction_during_pb_resolution() const;
1324  public:
1325  void clear_minimize_reduction_during_pb_resolution();
1326  bool minimize_reduction_during_pb_resolution() const;
1327  void set_minimize_reduction_during_pb_resolution(bool value);
1328  private:
1329  bool _internal_minimize_reduction_during_pb_resolution() const;
1330  void _internal_set_minimize_reduction_during_pb_resolution(bool value);
1331  public:
1332 
1333  // optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
1334  bool has_cp_model_postsolve_with_full_solver() const;
1335  private:
1336  bool _internal_has_cp_model_postsolve_with_full_solver() const;
1337  public:
1338  void clear_cp_model_postsolve_with_full_solver();
1339  bool cp_model_postsolve_with_full_solver() const;
1340  void set_cp_model_postsolve_with_full_solver(bool value);
1341  private:
1342  bool _internal_cp_model_postsolve_with_full_solver() const;
1343  void _internal_set_cp_model_postsolve_with_full_solver(bool value);
1344  public:
1345 
1346  // optional bool use_sat_inprocessing = 163 [default = false];
1347  bool has_use_sat_inprocessing() const;
1348  private:
1349  bool _internal_has_use_sat_inprocessing() const;
1350  public:
1351  void clear_use_sat_inprocessing();
1352  bool use_sat_inprocessing() const;
1353  void set_use_sat_inprocessing(bool value);
1354  private:
1355  bool _internal_use_sat_inprocessing() const;
1356  void _internal_set_use_sat_inprocessing(bool value);
1357  public:
1358 
1359  // optional bool optimize_with_core = 83 [default = false];
1360  bool has_optimize_with_core() const;
1361  private:
1362  bool _internal_has_optimize_with_core() const;
1363  public:
1364  void clear_optimize_with_core();
1365  bool optimize_with_core() const;
1366  void set_optimize_with_core(bool value);
1367  private:
1368  bool _internal_optimize_with_core() const;
1369  void _internal_set_optimize_with_core(bool value);
1370  public:
1371 
1372  // optional bool optimize_with_max_hs = 85 [default = false];
1373  bool has_optimize_with_max_hs() const;
1374  private:
1375  bool _internal_has_optimize_with_max_hs() const;
1376  public:
1377  void clear_optimize_with_max_hs();
1378  bool optimize_with_max_hs() const;
1379  void set_optimize_with_max_hs(bool value);
1380  private:
1381  bool _internal_optimize_with_max_hs() const;
1382  void _internal_set_optimize_with_max_hs(bool value);
1383  public:
1384 
1385  // optional bool enumerate_all_solutions = 87 [default = false];
1386  bool has_enumerate_all_solutions() const;
1387  private:
1388  bool _internal_has_enumerate_all_solutions() const;
1389  public:
1390  void clear_enumerate_all_solutions();
1391  bool enumerate_all_solutions() const;
1392  void set_enumerate_all_solutions(bool value);
1393  private:
1394  bool _internal_enumerate_all_solutions() const;
1395  void _internal_set_enumerate_all_solutions(bool value);
1396  public:
1397 
1398  // optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
1399  bool has_keep_all_feasible_solutions_in_presolve() const;
1400  private:
1401  bool _internal_has_keep_all_feasible_solutions_in_presolve() const;
1402  public:
1403  void clear_keep_all_feasible_solutions_in_presolve();
1404  bool keep_all_feasible_solutions_in_presolve() const;
1405  void set_keep_all_feasible_solutions_in_presolve(bool value);
1406  private:
1407  bool _internal_keep_all_feasible_solutions_in_presolve() const;
1408  void _internal_set_keep_all_feasible_solutions_in_presolve(bool value);
1409  public:
1410 
1411  // optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
1412  bool has_reduce_memory_usage_in_interleave_mode() const;
1413  private:
1414  bool _internal_has_reduce_memory_usage_in_interleave_mode() const;
1415  public:
1416  void clear_reduce_memory_usage_in_interleave_mode();
1417  bool reduce_memory_usage_in_interleave_mode() const;
1418  void set_reduce_memory_usage_in_interleave_mode(bool value);
1419  private:
1420  bool _internal_reduce_memory_usage_in_interleave_mode() const;
1421  void _internal_set_reduce_memory_usage_in_interleave_mode(bool value);
1422  public:
1423 
1424  // optional bool use_lns_only = 101 [default = false];
1425  bool has_use_lns_only() const;
1426  private:
1427  bool _internal_has_use_lns_only() const;
1428  public:
1429  void clear_use_lns_only();
1430  bool use_lns_only() const;
1431  void set_use_lns_only(bool value);
1432  private:
1433  bool _internal_use_lns_only() const;
1434  void _internal_set_use_lns_only(bool value);
1435  public:
1436 
1437  // optional bool lns_focus_on_decision_variables = 105 [default = false];
1438  bool has_lns_focus_on_decision_variables() const;
1439  private:
1440  bool _internal_has_lns_focus_on_decision_variables() const;
1441  public:
1442  void clear_lns_focus_on_decision_variables();
1443  bool lns_focus_on_decision_variables() const;
1444  void set_lns_focus_on_decision_variables(bool value);
1445  private:
1446  bool _internal_lns_focus_on_decision_variables() const;
1447  void _internal_set_lns_focus_on_decision_variables(bool value);
1448  public:
1449 
1450  // optional bool use_relaxation_lns = 150 [default = false];
1451  bool has_use_relaxation_lns() const;
1452  private:
1453  bool _internal_has_use_relaxation_lns() const;
1454  public:
1455  void clear_use_relaxation_lns();
1456  bool use_relaxation_lns() const;
1457  void set_use_relaxation_lns(bool value);
1458  private:
1459  bool _internal_use_relaxation_lns() const;
1460  void _internal_set_use_relaxation_lns(bool value);
1461  public:
1462 
1463  // optional bool diversify_lns_params = 137 [default = false];
1464  bool has_diversify_lns_params() const;
1465  private:
1466  bool _internal_has_diversify_lns_params() const;
1467  public:
1468  void clear_diversify_lns_params();
1469  bool diversify_lns_params() const;
1470  void set_diversify_lns_params(bool value);
1471  private:
1472  bool _internal_diversify_lns_params() const;
1473  void _internal_set_diversify_lns_params(bool value);
1474  public:
1475 
1476  // optional bool randomize_search = 103 [default = false];
1477  bool has_randomize_search() const;
1478  private:
1479  bool _internal_has_randomize_search() const;
1480  public:
1481  void clear_randomize_search();
1482  bool randomize_search() const;
1483  void set_randomize_search(bool value);
1484  private:
1485  bool _internal_randomize_search() const;
1486  void _internal_set_randomize_search(bool value);
1487  public:
1488 
1489  // optional bool use_branching_in_lp = 139 [default = false];
1490  bool has_use_branching_in_lp() const;
1491  private:
1492  bool _internal_has_use_branching_in_lp() const;
1493  public:
1494  void clear_use_branching_in_lp();
1495  bool use_branching_in_lp() const;
1496  void set_use_branching_in_lp(bool value);
1497  private:
1498  bool _internal_use_branching_in_lp() const;
1499  void _internal_set_use_branching_in_lp(bool value);
1500  public:
1501 
1502  // optional bool use_combined_no_overlap = 133 [default = false];
1503  bool has_use_combined_no_overlap() const;
1504  private:
1505  bool _internal_has_use_combined_no_overlap() const;
1506  public:
1507  void clear_use_combined_no_overlap();
1508  bool use_combined_no_overlap() const;
1509  void set_use_combined_no_overlap(bool value);
1510  private:
1511  bool _internal_use_combined_no_overlap() const;
1512  void _internal_set_use_combined_no_overlap(bool value);
1513  public:
1514 
1515  // optional bool fill_tightened_domains_in_response = 132 [default = false];
1516  bool has_fill_tightened_domains_in_response() const;
1517  private:
1518  bool _internal_has_fill_tightened_domains_in_response() const;
1519  public:
1520  void clear_fill_tightened_domains_in_response();
1521  bool fill_tightened_domains_in_response() const;
1522  void set_fill_tightened_domains_in_response(bool value);
1523  private:
1524  bool _internal_fill_tightened_domains_in_response() const;
1525  void _internal_set_fill_tightened_domains_in_response(bool value);
1526  public:
1527 
1528  // optional bool stop_after_first_solution = 98 [default = false];
1529  bool has_stop_after_first_solution() const;
1530  private:
1531  bool _internal_has_stop_after_first_solution() const;
1532  public:
1533  void clear_stop_after_first_solution();
1534  bool stop_after_first_solution() const;
1535  void set_stop_after_first_solution(bool value);
1536  private:
1537  bool _internal_stop_after_first_solution() const;
1538  void _internal_set_stop_after_first_solution(bool value);
1539  public:
1540 
1541  // optional bool stop_after_presolve = 149 [default = false];
1542  bool has_stop_after_presolve() const;
1543  private:
1544  bool _internal_has_stop_after_presolve() const;
1545  public:
1546  void clear_stop_after_presolve();
1547  bool stop_after_presolve() const;
1548  void set_stop_after_presolve(bool value);
1549  private:
1550  bool _internal_stop_after_presolve() const;
1551  void _internal_set_stop_after_presolve(bool value);
1552  public:
1553 
1554  // optional bool interleave_search = 136 [default = false];
1555  bool has_interleave_search() const;
1556  private:
1557  bool _internal_has_interleave_search() const;
1558  public:
1559  void clear_interleave_search();
1560  bool interleave_search() const;
1561  void set_interleave_search(bool value);
1562  private:
1563  bool _internal_interleave_search() const;
1564  void _internal_set_interleave_search(bool value);
1565  public:
1566 
1567  // optional bool expand_alldiff_constraints = 170 [default = false];
1568  bool has_expand_alldiff_constraints() const;
1569  private:
1570  bool _internal_has_expand_alldiff_constraints() const;
1571  public:
1572  void clear_expand_alldiff_constraints();
1573  bool expand_alldiff_constraints() const;
1574  void set_expand_alldiff_constraints(bool value);
1575  private:
1576  bool _internal_expand_alldiff_constraints() const;
1577  void _internal_set_expand_alldiff_constraints(bool value);
1578  public:
1579 
1580  // optional bool disable_constraint_expansion = 181 [default = false];
1581  bool has_disable_constraint_expansion() const;
1582  private:
1583  bool _internal_has_disable_constraint_expansion() const;
1584  public:
1585  void clear_disable_constraint_expansion();
1586  bool disable_constraint_expansion() const;
1587  void set_disable_constraint_expansion(bool value);
1588  private:
1589  bool _internal_disable_constraint_expansion() const;
1590  void _internal_set_disable_constraint_expansion(bool value);
1591  public:
1592 
1593  // optional bool presolve_extract_integer_enforcement = 174 [default = false];
1594  bool has_presolve_extract_integer_enforcement() const;
1595  private:
1596  bool _internal_has_presolve_extract_integer_enforcement() const;
1597  public:
1598  void clear_presolve_extract_integer_enforcement();
1599  bool presolve_extract_integer_enforcement() const;
1600  void set_presolve_extract_integer_enforcement(bool value);
1601  private:
1602  bool _internal_presolve_extract_integer_enforcement() const;
1603  void _internal_set_presolve_extract_integer_enforcement(bool value);
1604  public:
1605 
1606  // optional bool max_sat_reverse_assumption_order = 52 [default = false];
1607  bool has_max_sat_reverse_assumption_order() const;
1608  private:
1609  bool _internal_has_max_sat_reverse_assumption_order() const;
1610  public:
1611  void clear_max_sat_reverse_assumption_order();
1612  bool max_sat_reverse_assumption_order() const;
1613  void set_max_sat_reverse_assumption_order(bool value);
1614  private:
1615  bool _internal_max_sat_reverse_assumption_order() const;
1616  void _internal_set_max_sat_reverse_assumption_order(bool value);
1617  public:
1618 
1619  // optional int64 probing_period_at_root = 142 [default = 0];
1620  bool has_probing_period_at_root() const;
1621  private:
1622  bool _internal_has_probing_period_at_root() const;
1623  public:
1624  void clear_probing_period_at_root();
1625  ::PROTOBUF_NAMESPACE_ID::int64 probing_period_at_root() const;
1626  void set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value);
1627  private:
1628  ::PROTOBUF_NAMESPACE_ID::int64 _internal_probing_period_at_root() const;
1629  void _internal_set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value);
1630  public:
1631 
1632  // optional bool permute_presolve_constraint_order = 179 [default = false];
1633  bool has_permute_presolve_constraint_order() const;
1634  private:
1635  bool _internal_has_permute_presolve_constraint_order() const;
1636  public:
1637  void clear_permute_presolve_constraint_order();
1638  bool permute_presolve_constraint_order() const;
1639  void set_permute_presolve_constraint_order(bool value);
1640  private:
1641  bool _internal_permute_presolve_constraint_order() const;
1642  void _internal_set_permute_presolve_constraint_order(bool value);
1643  public:
1644 
1645  // optional bool use_absl_random = 180 [default = false];
1646  bool has_use_absl_random() const;
1647  private:
1648  bool _internal_has_use_absl_random() const;
1649  public:
1650  void clear_use_absl_random();
1651  bool use_absl_random() const;
1652  void set_use_absl_random(bool value);
1653  private:
1654  bool _internal_use_absl_random() const;
1655  void _internal_set_use_absl_random(bool value);
1656  public:
1657 
1658  // optional bool log_search_progress = 41 [default = false];
1659  bool has_log_search_progress() const;
1660  private:
1661  bool _internal_has_log_search_progress() const;
1662  public:
1663  void clear_log_search_progress();
1664  bool log_search_progress() const;
1665  void set_log_search_progress(bool value);
1666  private:
1667  bool _internal_log_search_progress() const;
1668  void _internal_set_log_search_progress(bool value);
1669  public:
1670 
1671  // optional bool fill_logs_in_response = 185 [default = false];
1672  bool has_fill_logs_in_response() const;
1673  private:
1674  bool _internal_has_fill_logs_in_response() const;
1675  public:
1676  void clear_fill_logs_in_response();
1677  bool fill_logs_in_response() const;
1678  void set_fill_logs_in_response(bool value);
1679  private:
1680  bool _internal_fill_logs_in_response() const;
1681  void _internal_set_fill_logs_in_response(bool value);
1682  public:
1683 
1684  // optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
1685  bool has_cp_model_max_num_presolve_operations() const;
1686  private:
1687  bool _internal_has_cp_model_max_num_presolve_operations() const;
1688  public:
1689  void clear_cp_model_max_num_presolve_operations();
1690  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_max_num_presolve_operations() const;
1691  void set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value);
1692  private:
1693  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cp_model_max_num_presolve_operations() const;
1694  void _internal_set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value);
1695  public:
1696 
1697  // optional double absolute_gap_limit = 159 [default = 0];
1698  bool has_absolute_gap_limit() const;
1699  private:
1700  bool _internal_has_absolute_gap_limit() const;
1701  public:
1702  void clear_absolute_gap_limit();
1703  double absolute_gap_limit() const;
1704  void set_absolute_gap_limit(double value);
1705  private:
1706  double _internal_absolute_gap_limit() const;
1707  void _internal_set_absolute_gap_limit(double value);
1708  public:
1709 
1710  // optional double relative_gap_limit = 160 [default = 0];
1711  bool has_relative_gap_limit() const;
1712  private:
1713  bool _internal_has_relative_gap_limit() const;
1714  public:
1715  void clear_relative_gap_limit();
1716  double relative_gap_limit() const;
1717  void set_relative_gap_limit(double value);
1718  private:
1719  double _internal_relative_gap_limit() const;
1720  void _internal_set_relative_gap_limit(double value);
1721  public:
1722 
1723  // optional bool repair_hint = 167 [default = false];
1724  bool has_repair_hint() const;
1725  private:
1726  bool _internal_has_repair_hint() const;
1727  public:
1728  void clear_repair_hint();
1729  bool repair_hint() const;
1730  void set_repair_hint(bool value);
1731  private:
1732  bool _internal_repair_hint() const;
1733  void _internal_set_repair_hint(bool value);
1734  public:
1735 
1736  // optional bool exploit_best_solution = 130 [default = false];
1737  bool has_exploit_best_solution() const;
1738  private:
1739  bool _internal_has_exploit_best_solution() const;
1740  public:
1741  void clear_exploit_best_solution();
1742  bool exploit_best_solution() const;
1743  void set_exploit_best_solution(bool value);
1744  private:
1745  bool _internal_exploit_best_solution() const;
1746  void _internal_set_exploit_best_solution(bool value);
1747  public:
1748 
1749  // optional bool exploit_relaxation_solution = 161 [default = false];
1750  bool has_exploit_relaxation_solution() const;
1751  private:
1752  bool _internal_has_exploit_relaxation_solution() const;
1753  public:
1754  void clear_exploit_relaxation_solution();
1755  bool exploit_relaxation_solution() const;
1756  void set_exploit_relaxation_solution(bool value);
1757  private:
1758  bool _internal_exploit_relaxation_solution() const;
1759  void _internal_set_exploit_relaxation_solution(bool value);
1760  public:
1761 
1762  // optional bool use_probing_search = 176 [default = false];
1763  bool has_use_probing_search() const;
1764  private:
1765  bool _internal_has_use_probing_search() const;
1766  public:
1767  void clear_use_probing_search();
1768  bool use_probing_search() const;
1769  void set_use_probing_search(bool value);
1770  private:
1771  bool _internal_use_probing_search() const;
1772  void _internal_set_use_probing_search(bool value);
1773  public:
1774 
1775  // optional bool polish_lp_solution = 175 [default = false];
1776  bool has_polish_lp_solution() const;
1777  private:
1778  bool _internal_has_polish_lp_solution() const;
1779  public:
1780  void clear_polish_lp_solution();
1781  bool polish_lp_solution() const;
1782  void set_polish_lp_solution(bool value);
1783  private:
1784  bool _internal_polish_lp_solution() const;
1785  void _internal_set_polish_lp_solution(bool value);
1786  public:
1787 
1788  // optional bool convert_intervals = 177 [default = false];
1789  bool has_convert_intervals() const;
1790  private:
1791  bool _internal_has_convert_intervals() const;
1792  public:
1793  void clear_convert_intervals();
1794  bool convert_intervals() const;
1795  void set_convert_intervals(bool value);
1796  private:
1797  bool _internal_convert_intervals() const;
1798  void _internal_set_convert_intervals(bool value);
1799  public:
1800 
1801  // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
1802  bool has_initial_polarity() const;
1803  private:
1804  bool _internal_has_initial_polarity() const;
1805  public:
1806  void clear_initial_polarity();
1807  ::operations_research::sat::SatParameters_Polarity initial_polarity() const;
1808  void set_initial_polarity(::operations_research::sat::SatParameters_Polarity value);
1809  private:
1810  ::operations_research::sat::SatParameters_Polarity _internal_initial_polarity() const;
1811  void _internal_set_initial_polarity(::operations_research::sat::SatParameters_Polarity value);
1812  public:
1813 
1814  // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
1815  bool has_minimization_algorithm() const;
1816  private:
1817  bool _internal_has_minimization_algorithm() const;
1818  public:
1819  void clear_minimization_algorithm();
1820  ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm minimization_algorithm() const;
1821  void set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value);
1822  private:
1823  ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm _internal_minimization_algorithm() const;
1824  void _internal_set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value);
1825  public:
1826 
1827  // optional int32 clause_cleanup_period = 11 [default = 10000];
1828  bool has_clause_cleanup_period() const;
1829  private:
1830  bool _internal_has_clause_cleanup_period() const;
1831  public:
1832  void clear_clause_cleanup_period();
1833  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period() const;
1834  void set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1835  private:
1836  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_period() const;
1837  void _internal_set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1838  public:
1839 
1840  // optional int32 clause_cleanup_target = 13 [default = 10000];
1841  bool has_clause_cleanup_target() const;
1842  private:
1843  bool _internal_has_clause_cleanup_target() const;
1844  public:
1845  void clear_clause_cleanup_target();
1846  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target() const;
1847  void set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
1848  private:
1849  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_target() const;
1850  void _internal_set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
1851  public:
1852 
1853  // optional double variable_activity_decay = 15 [default = 0.8];
1854  bool has_variable_activity_decay() const;
1855  private:
1856  bool _internal_has_variable_activity_decay() const;
1857  public:
1858  void clear_variable_activity_decay();
1859  double variable_activity_decay() const;
1860  void set_variable_activity_decay(double value);
1861  private:
1862  double _internal_variable_activity_decay() const;
1863  void _internal_set_variable_activity_decay(double value);
1864  public:
1865 
1866  // optional double max_variable_activity_value = 16 [default = 1e+100];
1867  bool has_max_variable_activity_value() const;
1868  private:
1869  bool _internal_has_max_variable_activity_value() const;
1870  public:
1871  void clear_max_variable_activity_value();
1872  double max_variable_activity_value() const;
1873  void set_max_variable_activity_value(double value);
1874  private:
1875  double _internal_max_variable_activity_value() const;
1876  void _internal_set_max_variable_activity_value(double value);
1877  public:
1878 
1879  // optional double clause_activity_decay = 17 [default = 0.999];
1880  bool has_clause_activity_decay() const;
1881  private:
1882  bool _internal_has_clause_activity_decay() const;
1883  public:
1884  void clear_clause_activity_decay();
1885  double clause_activity_decay() const;
1886  void set_clause_activity_decay(double value);
1887  private:
1888  double _internal_clause_activity_decay() const;
1889  void _internal_set_clause_activity_decay(double value);
1890  public:
1891 
1892  // optional double max_clause_activity_value = 18 [default = 1e+20];
1893  bool has_max_clause_activity_value() const;
1894  private:
1895  bool _internal_has_max_clause_activity_value() const;
1896  public:
1897  void clear_max_clause_activity_value();
1898  double max_clause_activity_value() const;
1899  void set_max_clause_activity_value(double value);
1900  private:
1901  double _internal_max_clause_activity_value() const;
1902  void _internal_set_max_clause_activity_value(double value);
1903  public:
1904 
1905  // optional double glucose_max_decay = 22 [default = 0.95];
1906  bool has_glucose_max_decay() const;
1907  private:
1908  bool _internal_has_glucose_max_decay() const;
1909  public:
1910  void clear_glucose_max_decay();
1911  double glucose_max_decay() const;
1912  void set_glucose_max_decay(double value);
1913  private:
1914  double _internal_glucose_max_decay() const;
1915  void _internal_set_glucose_max_decay(double value);
1916  public:
1917 
1918  // optional double glucose_decay_increment = 23 [default = 0.01];
1919  bool has_glucose_decay_increment() const;
1920  private:
1921  bool _internal_has_glucose_decay_increment() const;
1922  public:
1923  void clear_glucose_decay_increment();
1924  double glucose_decay_increment() const;
1925  void set_glucose_decay_increment(double value);
1926  private:
1927  double _internal_glucose_decay_increment() const;
1928  void _internal_set_glucose_decay_increment(double value);
1929  public:
1930 
1931  // optional int32 glucose_decay_increment_period = 24 [default = 5000];
1932  bool has_glucose_decay_increment_period() const;
1933  private:
1934  bool _internal_has_glucose_decay_increment_period() const;
1935  public:
1936  void clear_glucose_decay_increment_period();
1937  ::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period() const;
1938  void set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1939  private:
1940  ::PROTOBUF_NAMESPACE_ID::int32 _internal_glucose_decay_increment_period() const;
1941  void _internal_set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1942  public:
1943 
1944  // optional int32 restart_period = 30 [default = 50];
1945  bool has_restart_period() const;
1946  private:
1947  bool _internal_has_restart_period() const;
1948  public:
1949  void clear_restart_period();
1950  ::PROTOBUF_NAMESPACE_ID::int32 restart_period() const;
1951  void set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1952  private:
1953  ::PROTOBUF_NAMESPACE_ID::int32 _internal_restart_period() const;
1954  void _internal_set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
1955  public:
1956 
1957  // optional int32 random_seed = 31 [default = 1];
1958  bool has_random_seed() const;
1959  private:
1960  bool _internal_has_random_seed() const;
1961  public:
1962  void clear_random_seed();
1963  ::PROTOBUF_NAMESPACE_ID::int32 random_seed() const;
1964  void set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value);
1965  private:
1966  ::PROTOBUF_NAMESPACE_ID::int32 _internal_random_seed() const;
1967  void _internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value);
1968  public:
1969 
1970  // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
1971  bool has_binary_minimization_algorithm() const;
1972  private:
1973  bool _internal_has_binary_minimization_algorithm() const;
1974  public:
1975  void clear_binary_minimization_algorithm();
1976  ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm binary_minimization_algorithm() const;
1977  void set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value);
1978  private:
1979  ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm _internal_binary_minimization_algorithm() const;
1980  void _internal_set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value);
1981  public:
1982 
1983  // optional double max_time_in_seconds = 36 [default = inf];
1984  bool has_max_time_in_seconds() const;
1985  private:
1986  bool _internal_has_max_time_in_seconds() const;
1987  public:
1988  void clear_max_time_in_seconds();
1989  double max_time_in_seconds() const;
1990  void set_max_time_in_seconds(double value);
1991  private:
1992  double _internal_max_time_in_seconds() const;
1993  void _internal_set_max_time_in_seconds(double value);
1994  public:
1995 
1996  // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
1997  bool has_max_number_of_conflicts() const;
1998  private:
1999  bool _internal_has_max_number_of_conflicts() const;
2000  public:
2001  void clear_max_number_of_conflicts();
2002  ::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts() const;
2003  void set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value);
2004  private:
2005  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_number_of_conflicts() const;
2006  void _internal_set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value);
2007  public:
2008 
2009  // optional int64 max_memory_in_mb = 40 [default = 10000];
2010  bool has_max_memory_in_mb() const;
2011  private:
2012  bool _internal_has_max_memory_in_mb() const;
2013  public:
2014  void clear_max_memory_in_mb();
2015  ::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb() const;
2016  void set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value);
2017  private:
2018  ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_memory_in_mb() const;
2019  void _internal_set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value);
2020  public:
2021 
2022  // optional bool use_phase_saving = 44 [default = true];
2023  bool has_use_phase_saving() const;
2024  private:
2025  bool _internal_has_use_phase_saving() const;
2026  public:
2027  void clear_use_phase_saving();
2028  bool use_phase_saving() const;
2029  void set_use_phase_saving(bool value);
2030  private:
2031  bool _internal_use_phase_saving() const;
2032  void _internal_set_use_phase_saving(bool value);
2033  public:
2034 
2035  // optional bool subsumption_during_conflict_analysis = 56 [default = true];
2036  bool has_subsumption_during_conflict_analysis() const;
2037  private:
2038  bool _internal_has_subsumption_during_conflict_analysis() const;
2039  public:
2040  void clear_subsumption_during_conflict_analysis();
2041  bool subsumption_during_conflict_analysis() const;
2042  void set_subsumption_during_conflict_analysis(bool value);
2043  private:
2044  bool _internal_subsumption_during_conflict_analysis() const;
2045  void _internal_set_subsumption_during_conflict_analysis(bool value);
2046  public:
2047 
2048  // optional bool treat_binary_clauses_separately = 33 [default = true];
2049  bool has_treat_binary_clauses_separately() const;
2050  private:
2051  bool _internal_has_treat_binary_clauses_separately() const;
2052  public:
2053  void clear_treat_binary_clauses_separately();
2054  bool treat_binary_clauses_separately() const;
2055  void set_treat_binary_clauses_separately(bool value);
2056  private:
2057  bool _internal_treat_binary_clauses_separately() const;
2058  void _internal_set_treat_binary_clauses_separately(bool value);
2059  public:
2060 
2061  // optional bool count_assumption_levels_in_lbd = 49 [default = true];
2062  bool has_count_assumption_levels_in_lbd() const;
2063  private:
2064  bool _internal_has_count_assumption_levels_in_lbd() const;
2065  public:
2066  void clear_count_assumption_levels_in_lbd();
2067  bool count_assumption_levels_in_lbd() const;
2068  void set_count_assumption_levels_in_lbd(bool value);
2069  private:
2070  bool _internal_count_assumption_levels_in_lbd() const;
2071  void _internal_set_count_assumption_levels_in_lbd(bool value);
2072  public:
2073 
2074  // optional int32 pb_cleanup_increment = 46 [default = 200];
2075  bool has_pb_cleanup_increment() const;
2076  private:
2077  bool _internal_has_pb_cleanup_increment() const;
2078  public:
2079  void clear_pb_cleanup_increment();
2080  ::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment() const;
2081  void set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
2082  private:
2083  ::PROTOBUF_NAMESPACE_ID::int32 _internal_pb_cleanup_increment() const;
2084  void _internal_set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
2085  public:
2086 
2087  // optional double pb_cleanup_ratio = 47 [default = 0.5];
2088  bool has_pb_cleanup_ratio() const;
2089  private:
2090  bool _internal_has_pb_cleanup_ratio() const;
2091  public:
2092  void clear_pb_cleanup_ratio();
2093  double pb_cleanup_ratio() const;
2094  void set_pb_cleanup_ratio(double value);
2095  private:
2096  double _internal_pb_cleanup_ratio() const;
2097  void _internal_set_pb_cleanup_ratio(double value);
2098  public:
2099 
2100  // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
2101  bool has_max_sat_stratification() const;
2102  private:
2103  bool _internal_has_max_sat_stratification() const;
2104  public:
2105  void clear_max_sat_stratification();
2106  ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm max_sat_stratification() const;
2107  void set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value);
2108  private:
2109  ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm _internal_max_sat_stratification() const;
2110  void _internal_set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value);
2111  public:
2112 
2113  // optional int32 presolve_bve_threshold = 54 [default = 500];
2114  bool has_presolve_bve_threshold() const;
2115  private:
2116  bool _internal_has_presolve_bve_threshold() const;
2117  public:
2118  void clear_presolve_bve_threshold();
2119  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold() const;
2120  void set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
2121  private:
2122  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bve_threshold() const;
2123  void _internal_set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
2124  public:
2125 
2126  // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
2127  bool has_presolve_probing_deterministic_time_limit() const;
2128  private:
2129  bool _internal_has_presolve_probing_deterministic_time_limit() const;
2130  public:
2131  void clear_presolve_probing_deterministic_time_limit();
2132  double presolve_probing_deterministic_time_limit() const;
2133  void set_presolve_probing_deterministic_time_limit(double value);
2134  private:
2135  double _internal_presolve_probing_deterministic_time_limit() const;
2136  void _internal_set_presolve_probing_deterministic_time_limit(double value);
2137  public:
2138 
2139  // optional int32 presolve_bve_clause_weight = 55 [default = 3];
2140  bool has_presolve_bve_clause_weight() const;
2141  private:
2142  bool _internal_has_presolve_bve_clause_weight() const;
2143  public:
2144  void clear_presolve_bve_clause_weight();
2145  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight() const;
2146  void set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value);
2147  private:
2148  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bve_clause_weight() const;
2149  void _internal_set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value);
2150  public:
2151 
2152  // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
2153  bool has_clause_cleanup_lbd_bound() const;
2154  private:
2155  bool _internal_has_clause_cleanup_lbd_bound() const;
2156  public:
2157  void clear_clause_cleanup_lbd_bound();
2158  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound() const;
2159  void set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value);
2160  private:
2161  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clause_cleanup_lbd_bound() const;
2162  void _internal_set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value);
2163  public:
2164 
2165  // optional double restart_dl_average_ratio = 63 [default = 1];
2166  bool has_restart_dl_average_ratio() const;
2167  private:
2168  bool _internal_has_restart_dl_average_ratio() const;
2169  public:
2170  void clear_restart_dl_average_ratio();
2171  double restart_dl_average_ratio() const;
2172  void set_restart_dl_average_ratio(double value);
2173  private:
2174  double _internal_restart_dl_average_ratio() const;
2175  void _internal_set_restart_dl_average_ratio(double value);
2176  public:
2177 
2178  // optional int32 restart_running_window_size = 62 [default = 50];
2179  bool has_restart_running_window_size() const;
2180  private:
2181  bool _internal_has_restart_running_window_size() const;
2182  public:
2183  void clear_restart_running_window_size();
2184  ::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size() const;
2185  void set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2186  private:
2187  ::PROTOBUF_NAMESPACE_ID::int32 _internal_restart_running_window_size() const;
2188  void _internal_set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2189  public:
2190 
2191  // optional bool use_optimization_hints = 35 [default = true];
2192  bool has_use_optimization_hints() const;
2193  private:
2194  bool _internal_has_use_optimization_hints() const;
2195  public:
2196  void clear_use_optimization_hints();
2197  bool use_optimization_hints() const;
2198  void set_use_optimization_hints(bool value);
2199  private:
2200  bool _internal_use_optimization_hints() const;
2201  void _internal_set_use_optimization_hints(bool value);
2202  public:
2203 
2204  // optional bool minimize_core = 50 [default = true];
2205  bool has_minimize_core() const;
2206  private:
2207  bool _internal_has_minimize_core() const;
2208  public:
2209  void clear_minimize_core();
2210  bool minimize_core() const;
2211  void set_minimize_core(bool value);
2212  private:
2213  bool _internal_minimize_core() const;
2214  void _internal_set_minimize_core(bool value);
2215  public:
2216 
2217  // optional bool find_multiple_cores = 84 [default = true];
2218  bool has_find_multiple_cores() const;
2219  private:
2220  bool _internal_has_find_multiple_cores() const;
2221  public:
2222  void clear_find_multiple_cores();
2223  bool find_multiple_cores() const;
2224  void set_find_multiple_cores(bool value);
2225  private:
2226  bool _internal_find_multiple_cores() const;
2227  void _internal_set_find_multiple_cores(bool value);
2228  public:
2229 
2230  // optional bool cover_optimization = 89 [default = true];
2231  bool has_cover_optimization() const;
2232  private:
2233  bool _internal_has_cover_optimization() const;
2234  public:
2235  void clear_cover_optimization();
2236  bool cover_optimization() const;
2237  void set_cover_optimization(bool value);
2238  private:
2239  bool _internal_cover_optimization() const;
2240  void _internal_set_cover_optimization(bool value);
2241  public:
2242 
2243  // optional double blocking_restart_multiplier = 66 [default = 1.4];
2244  bool has_blocking_restart_multiplier() const;
2245  private:
2246  bool _internal_has_blocking_restart_multiplier() const;
2247  public:
2248  void clear_blocking_restart_multiplier();
2249  double blocking_restart_multiplier() const;
2250  void set_blocking_restart_multiplier(double value);
2251  private:
2252  double _internal_blocking_restart_multiplier() const;
2253  void _internal_set_blocking_restart_multiplier(double value);
2254  public:
2255 
2256  // optional double max_deterministic_time = 67 [default = inf];
2257  bool has_max_deterministic_time() const;
2258  private:
2259  bool _internal_has_max_deterministic_time() const;
2260  public:
2261  void clear_max_deterministic_time();
2262  double max_deterministic_time() const;
2263  void set_max_deterministic_time(double value);
2264  private:
2265  double _internal_max_deterministic_time() const;
2266  void _internal_set_max_deterministic_time(double value);
2267  public:
2268 
2269  // optional int32 blocking_restart_window_size = 65 [default = 5000];
2270  bool has_blocking_restart_window_size() const;
2271  private:
2272  bool _internal_has_blocking_restart_window_size() const;
2273  public:
2274  void clear_blocking_restart_window_size();
2275  ::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size() const;
2276  void set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2277  private:
2278  ::PROTOBUF_NAMESPACE_ID::int32 _internal_blocking_restart_window_size() const;
2279  void _internal_set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2280  public:
2281 
2282  // optional int32 presolve_bva_threshold = 73 [default = 1];
2283  bool has_presolve_bva_threshold() const;
2284  private:
2285  bool _internal_has_presolve_bva_threshold() const;
2286  public:
2287  void clear_presolve_bva_threshold();
2288  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold() const;
2289  void set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
2290  private:
2291  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_bva_threshold() const;
2292  void _internal_set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value);
2293  public:
2294 
2295  // optional double restart_lbd_average_ratio = 71 [default = 1];
2296  bool has_restart_lbd_average_ratio() const;
2297  private:
2298  bool _internal_has_restart_lbd_average_ratio() const;
2299  public:
2300  void clear_restart_lbd_average_ratio();
2301  double restart_lbd_average_ratio() const;
2302  void set_restart_lbd_average_ratio(double value);
2303  private:
2304  double _internal_restart_lbd_average_ratio() const;
2305  void _internal_set_restart_lbd_average_ratio(double value);
2306  public:
2307 
2308  // optional bool presolve_blocked_clause = 88 [default = true];
2309  bool has_presolve_blocked_clause() const;
2310  private:
2311  bool _internal_has_presolve_blocked_clause() const;
2312  public:
2313  void clear_presolve_blocked_clause();
2314  bool presolve_blocked_clause() const;
2315  void set_presolve_blocked_clause(bool value);
2316  private:
2317  bool _internal_presolve_blocked_clause() const;
2318  void _internal_set_presolve_blocked_clause(bool value);
2319  public:
2320 
2321  // optional bool presolve_use_bva = 72 [default = true];
2322  bool has_presolve_use_bva() const;
2323  private:
2324  bool _internal_has_presolve_use_bva() const;
2325  public:
2326  void clear_presolve_use_bva();
2327  bool presolve_use_bva() const;
2328  void set_presolve_use_bva(bool value);
2329  private:
2330  bool _internal_presolve_use_bva() const;
2331  void _internal_set_presolve_use_bva(bool value);
2332  public:
2333 
2334  // optional bool cp_model_presolve = 86 [default = true];
2335  bool has_cp_model_presolve() const;
2336  private:
2337  bool _internal_has_cp_model_presolve() const;
2338  public:
2339  void clear_cp_model_presolve();
2340  bool cp_model_presolve() const;
2341  void set_cp_model_presolve(bool value);
2342  private:
2343  bool _internal_cp_model_presolve() const;
2344  void _internal_set_cp_model_presolve(bool value);
2345  public:
2346 
2347  // optional bool cp_model_use_sat_presolve = 93 [default = true];
2348  bool has_cp_model_use_sat_presolve() const;
2349  private:
2350  bool _internal_has_cp_model_use_sat_presolve() const;
2351  public:
2352  void clear_cp_model_use_sat_presolve();
2353  bool cp_model_use_sat_presolve() const;
2354  void set_cp_model_use_sat_presolve(bool value);
2355  private:
2356  bool _internal_cp_model_use_sat_presolve() const;
2357  void _internal_set_cp_model_use_sat_presolve(bool value);
2358  public:
2359 
2360  // optional int32 linearization_level = 90 [default = 1];
2361  bool has_linearization_level() const;
2362  private:
2363  bool _internal_has_linearization_level() const;
2364  public:
2365  void clear_linearization_level();
2366  ::PROTOBUF_NAMESPACE_ID::int32 linearization_level() const;
2367  void set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2368  private:
2369  ::PROTOBUF_NAMESPACE_ID::int32 _internal_linearization_level() const;
2370  void _internal_set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2371  public:
2372 
2373  // optional int32 max_num_cuts = 91 [default = 10000];
2374  bool has_max_num_cuts() const;
2375  private:
2376  bool _internal_has_max_num_cuts() const;
2377  public:
2378  void clear_max_num_cuts();
2379  ::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts() const;
2380  void set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value);
2381  private:
2382  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_num_cuts() const;
2383  void _internal_set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value);
2384  public:
2385 
2386  // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
2387  bool has_minimize_with_propagation_restart_period() const;
2388  private:
2389  bool _internal_has_minimize_with_propagation_restart_period() const;
2390  public:
2391  void clear_minimize_with_propagation_restart_period();
2392  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period() const;
2393  void set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
2394  private:
2395  ::PROTOBUF_NAMESPACE_ID::int32 _internal_minimize_with_propagation_restart_period() const;
2396  void _internal_set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value);
2397  public:
2398 
2399  // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
2400  bool has_minimize_with_propagation_num_decisions() const;
2401  private:
2402  bool _internal_has_minimize_with_propagation_num_decisions() const;
2403  public:
2404  void clear_minimize_with_propagation_num_decisions();
2405  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions() const;
2406  void set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value);
2407  private:
2408  ::PROTOBUF_NAMESPACE_ID::int32 _internal_minimize_with_propagation_num_decisions() const;
2409  void _internal_set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value);
2410  public:
2411 
2412  // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
2413  bool has_use_precedences_in_disjunctive_constraint() const;
2414  private:
2415  bool _internal_has_use_precedences_in_disjunctive_constraint() const;
2416  public:
2417  void clear_use_precedences_in_disjunctive_constraint();
2418  bool use_precedences_in_disjunctive_constraint() const;
2419  void set_use_precedences_in_disjunctive_constraint(bool value);
2420  private:
2421  bool _internal_use_precedences_in_disjunctive_constraint() const;
2422  void _internal_set_use_precedences_in_disjunctive_constraint(bool value);
2423  public:
2424 
2425  // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
2426  bool has_use_disjunctive_constraint_in_cumulative_constraint() const;
2427  private:
2428  bool _internal_has_use_disjunctive_constraint_in_cumulative_constraint() const;
2429  public:
2430  void clear_use_disjunctive_constraint_in_cumulative_constraint();
2431  bool use_disjunctive_constraint_in_cumulative_constraint() const;
2432  void set_use_disjunctive_constraint_in_cumulative_constraint(bool value);
2433  private:
2434  bool _internal_use_disjunctive_constraint_in_cumulative_constraint() const;
2435  void _internal_set_use_disjunctive_constraint_in_cumulative_constraint(bool value);
2436  public:
2437 
2438  // optional bool add_cg_cuts = 117 [default = true];
2439  bool has_add_cg_cuts() const;
2440  private:
2441  bool _internal_has_add_cg_cuts() const;
2442  public:
2443  void clear_add_cg_cuts();
2444  bool add_cg_cuts() const;
2445  void set_add_cg_cuts(bool value);
2446  private:
2447  bool _internal_add_cg_cuts() const;
2448  void _internal_set_add_cg_cuts(bool value);
2449  public:
2450 
2451  // optional bool add_mir_cuts = 120 [default = true];
2452  bool has_add_mir_cuts() const;
2453  private:
2454  bool _internal_has_add_mir_cuts() const;
2455  public:
2456  void clear_add_mir_cuts();
2457  bool add_mir_cuts() const;
2458  void set_add_mir_cuts(bool value);
2459  private:
2460  bool _internal_add_mir_cuts() const;
2461  void _internal_set_add_mir_cuts(bool value);
2462  public:
2463 
2464  // optional int32 binary_search_num_conflicts = 99 [default = -1];
2465  bool has_binary_search_num_conflicts() const;
2466  private:
2467  bool _internal_has_binary_search_num_conflicts() const;
2468  public:
2469  void clear_binary_search_num_conflicts();
2470  ::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts() const;
2471  void set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value);
2472  private:
2473  ::PROTOBUF_NAMESPACE_ID::int32 _internal_binary_search_num_conflicts() const;
2474  void _internal_set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value);
2475  public:
2476 
2477  // optional int32 num_search_workers = 100 [default = 1];
2478  bool has_num_search_workers() const;
2479  private:
2480  bool _internal_has_num_search_workers() const;
2481  public:
2482  void clear_num_search_workers();
2483  ::PROTOBUF_NAMESPACE_ID::int32 num_search_workers() const;
2484  void set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
2485  private:
2486  ::PROTOBUF_NAMESPACE_ID::int32 _internal_num_search_workers() const;
2487  void _internal_set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value);
2488  public:
2489 
2490  // optional int32 boolean_encoding_level = 107 [default = 1];
2491  bool has_boolean_encoding_level() const;
2492  private:
2493  bool _internal_has_boolean_encoding_level() const;
2494  public:
2495  void clear_boolean_encoding_level();
2496  ::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level() const;
2497  void set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2498  private:
2499  ::PROTOBUF_NAMESPACE_ID::int32 _internal_boolean_encoding_level() const;
2500  void _internal_set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2501  public:
2502 
2503  // optional int32 cp_model_probing_level = 110 [default = 2];
2504  bool has_cp_model_probing_level() const;
2505  private:
2506  bool _internal_has_cp_model_probing_level() const;
2507  public:
2508  void clear_cp_model_probing_level();
2509  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level() const;
2510  void set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2511  private:
2512  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cp_model_probing_level() const;
2513  void _internal_set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2514  public:
2515 
2516  // optional bool exploit_integer_lp_solution = 94 [default = true];
2517  bool has_exploit_integer_lp_solution() const;
2518  private:
2519  bool _internal_has_exploit_integer_lp_solution() const;
2520  public:
2521  void clear_exploit_integer_lp_solution();
2522  bool exploit_integer_lp_solution() const;
2523  void set_exploit_integer_lp_solution(bool value);
2524  private:
2525  bool _internal_exploit_integer_lp_solution() const;
2526  void _internal_set_exploit_integer_lp_solution(bool value);
2527  public:
2528 
2529  // optional bool exploit_all_lp_solution = 116 [default = true];
2530  bool has_exploit_all_lp_solution() const;
2531  private:
2532  bool _internal_has_exploit_all_lp_solution() const;
2533  public:
2534  void clear_exploit_all_lp_solution();
2535  bool exploit_all_lp_solution() const;
2536  void set_exploit_all_lp_solution(bool value);
2537  private:
2538  bool _internal_exploit_all_lp_solution() const;
2539  void _internal_set_exploit_all_lp_solution(bool value);
2540  public:
2541 
2542  // optional bool exploit_objective = 131 [default = true];
2543  bool has_exploit_objective() const;
2544  private:
2545  bool _internal_has_exploit_objective() const;
2546  public:
2547  void clear_exploit_objective();
2548  bool exploit_objective() const;
2549  void set_exploit_objective(bool value);
2550  private:
2551  bool _internal_exploit_objective() const;
2552  void _internal_set_exploit_objective(bool value);
2553  public:
2554 
2555  // optional bool instantiate_all_variables = 106 [default = true];
2556  bool has_instantiate_all_variables() const;
2557  private:
2558  bool _internal_has_instantiate_all_variables() const;
2559  public:
2560  void clear_instantiate_all_variables();
2561  bool instantiate_all_variables() const;
2562  void set_instantiate_all_variables(bool value);
2563  private:
2564  bool _internal_instantiate_all_variables() const;
2565  void _internal_set_instantiate_all_variables(bool value);
2566  public:
2567 
2568  // optional int32 max_integer_rounding_scaling = 119 [default = 600];
2569  bool has_max_integer_rounding_scaling() const;
2570  private:
2571  bool _internal_has_max_integer_rounding_scaling() const;
2572  public:
2573  void clear_max_integer_rounding_scaling();
2574  ::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling() const;
2575  void set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value);
2576  private:
2577  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_integer_rounding_scaling() const;
2578  void _internal_set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value);
2579  public:
2580 
2581  // optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
2582  bool has_min_orthogonality_for_lp_constraints() const;
2583  private:
2584  bool _internal_has_min_orthogonality_for_lp_constraints() const;
2585  public:
2586  void clear_min_orthogonality_for_lp_constraints();
2587  double min_orthogonality_for_lp_constraints() const;
2588  void set_min_orthogonality_for_lp_constraints(double value);
2589  private:
2590  double _internal_min_orthogonality_for_lp_constraints() const;
2591  void _internal_set_min_orthogonality_for_lp_constraints(double value);
2592  public:
2593 
2594  // optional int32 max_consecutive_inactive_count = 121 [default = 100];
2595  bool has_max_consecutive_inactive_count() const;
2596  private:
2597  bool _internal_has_max_consecutive_inactive_count() const;
2598  public:
2599  void clear_max_consecutive_inactive_count();
2600  ::PROTOBUF_NAMESPACE_ID::int32 max_consecutive_inactive_count() const;
2601  void set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value);
2602  private:
2603  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_consecutive_inactive_count() const;
2604  void _internal_set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value);
2605  public:
2606 
2607  // optional int32 new_constraints_batch_size = 122 [default = 50];
2608  bool has_new_constraints_batch_size() const;
2609  private:
2610  bool _internal_has_new_constraints_batch_size() const;
2611  public:
2612  void clear_new_constraints_batch_size();
2613  ::PROTOBUF_NAMESPACE_ID::int32 new_constraints_batch_size() const;
2614  void set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2615  private:
2616  ::PROTOBUF_NAMESPACE_ID::int32 _internal_new_constraints_batch_size() const;
2617  void _internal_set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2618  public:
2619 
2620  // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
2621  bool has_pseudo_cost_reliability_threshold() const;
2622  private:
2623  bool _internal_has_pseudo_cost_reliability_threshold() const;
2624  public:
2625  void clear_pseudo_cost_reliability_threshold();
2626  ::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold() const;
2627  void set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value);
2628  private:
2629  ::PROTOBUF_NAMESPACE_ID::int64 _internal_pseudo_cost_reliability_threshold() const;
2630  void _internal_set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value);
2631  public:
2632 
2633  // optional double mip_max_bound = 124 [default = 10000000];
2634  bool has_mip_max_bound() const;
2635  private:
2636  bool _internal_has_mip_max_bound() const;
2637  public:
2638  void clear_mip_max_bound();
2639  double mip_max_bound() const;
2640  void set_mip_max_bound(double value);
2641  private:
2642  double _internal_mip_max_bound() const;
2643  void _internal_set_mip_max_bound(double value);
2644  public:
2645 
2646  // optional double mip_var_scaling = 125 [default = 1];
2647  bool has_mip_var_scaling() const;
2648  private:
2649  bool _internal_has_mip_var_scaling() const;
2650  public:
2651  void clear_mip_var_scaling();
2652  double mip_var_scaling() const;
2653  void set_mip_var_scaling(double value);
2654  private:
2655  double _internal_mip_var_scaling() const;
2656  void _internal_set_mip_var_scaling(double value);
2657  public:
2658 
2659  // optional double mip_wanted_precision = 126 [default = 1e-06];
2660  bool has_mip_wanted_precision() const;
2661  private:
2662  bool _internal_has_mip_wanted_precision() const;
2663  public:
2664  void clear_mip_wanted_precision();
2665  double mip_wanted_precision() const;
2666  void set_mip_wanted_precision(double value);
2667  private:
2668  double _internal_mip_wanted_precision() const;
2669  void _internal_set_mip_wanted_precision(double value);
2670  public:
2671 
2672  // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
2673  bool has_auto_detect_greater_than_at_least_one_of() const;
2674  private:
2675  bool _internal_has_auto_detect_greater_than_at_least_one_of() const;
2676  public:
2677  void clear_auto_detect_greater_than_at_least_one_of();
2678  bool auto_detect_greater_than_at_least_one_of() const;
2679  void set_auto_detect_greater_than_at_least_one_of(bool value);
2680  private:
2681  bool _internal_auto_detect_greater_than_at_least_one_of() const;
2682  void _internal_set_auto_detect_greater_than_at_least_one_of(bool value);
2683  public:
2684 
2685  // optional bool share_objective_bounds = 113 [default = true];
2686  bool has_share_objective_bounds() const;
2687  private:
2688  bool _internal_has_share_objective_bounds() const;
2689  public:
2690  void clear_share_objective_bounds();
2691  bool share_objective_bounds() const;
2692  void set_share_objective_bounds(bool value);
2693  private:
2694  bool _internal_share_objective_bounds() const;
2695  void _internal_set_share_objective_bounds(bool value);
2696  public:
2697 
2698  // optional bool share_level_zero_bounds = 114 [default = true];
2699  bool has_share_level_zero_bounds() const;
2700  private:
2701  bool _internal_has_share_level_zero_bounds() const;
2702  public:
2703  void clear_share_level_zero_bounds();
2704  bool share_level_zero_bounds() const;
2705  void set_share_level_zero_bounds(bool value);
2706  private:
2707  bool _internal_share_level_zero_bounds() const;
2708  void _internal_set_share_level_zero_bounds(bool value);
2709  public:
2710 
2711  // optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];
2712  bool has_lns_expand_intervals_in_constraint_graph() const;
2713  private:
2714  bool _internal_has_lns_expand_intervals_in_constraint_graph() const;
2715  public:
2716  void clear_lns_expand_intervals_in_constraint_graph();
2717  bool lns_expand_intervals_in_constraint_graph() const;
2718  void set_lns_expand_intervals_in_constraint_graph(bool value);
2719  private:
2720  bool _internal_lns_expand_intervals_in_constraint_graph() const;
2721  void _internal_set_lns_expand_intervals_in_constraint_graph(bool value);
2722  public:
2723 
2724  // optional int32 mip_max_activity_exponent = 127 [default = 53];
2725  bool has_mip_max_activity_exponent() const;
2726  private:
2727  bool _internal_has_mip_max_activity_exponent() const;
2728  public:
2729  void clear_mip_max_activity_exponent();
2730  ::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent() const;
2731  void set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value);
2732  private:
2733  ::PROTOBUF_NAMESPACE_ID::int32 _internal_mip_max_activity_exponent() const;
2734  void _internal_set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value);
2735  public:
2736 
2737  // optional double mip_check_precision = 128 [default = 0.0001];
2738  bool has_mip_check_precision() const;
2739  private:
2740  bool _internal_has_mip_check_precision() const;
2741  public:
2742  void clear_mip_check_precision();
2743  double mip_check_precision() const;
2744  void set_mip_check_precision(double value);
2745  private:
2746  double _internal_mip_check_precision() const;
2747  void _internal_set_mip_check_precision(double value);
2748  public:
2749 
2750  // optional bool use_rins_lns = 129 [default = true];
2751  bool has_use_rins_lns() const;
2752  private:
2753  bool _internal_has_use_rins_lns() const;
2754  public:
2755  void clear_use_rins_lns();
2756  bool use_rins_lns() const;
2757  void set_use_rins_lns(bool value);
2758  private:
2759  bool _internal_use_rins_lns() const;
2760  void _internal_set_use_rins_lns(bool value);
2761  public:
2762 
2763  // optional bool use_feasibility_pump = 164 [default = true];
2764  bool has_use_feasibility_pump() const;
2765  private:
2766  bool _internal_has_use_feasibility_pump() const;
2767  public:
2768  void clear_use_feasibility_pump();
2769  bool use_feasibility_pump() const;
2770  void set_use_feasibility_pump(bool value);
2771  private:
2772  bool _internal_use_feasibility_pump() const;
2773  void _internal_set_use_feasibility_pump(bool value);
2774  public:
2775 
2776  // optional bool use_optional_variables = 108 [default = true];
2777  bool has_use_optional_variables() const;
2778  private:
2779  bool _internal_has_use_optional_variables() const;
2780  public:
2781  void clear_use_optional_variables();
2782  bool use_optional_variables() const;
2783  void set_use_optional_variables(bool value);
2784  private:
2785  bool _internal_use_optional_variables() const;
2786  void _internal_set_use_optional_variables(bool value);
2787  public:
2788 
2789  // optional bool use_exact_lp_reason = 109 [default = true];
2790  bool has_use_exact_lp_reason() const;
2791  private:
2792  bool _internal_has_use_exact_lp_reason() const;
2793  public:
2794  void clear_use_exact_lp_reason();
2795  bool use_exact_lp_reason() const;
2796  void set_use_exact_lp_reason(bool value);
2797  private:
2798  bool _internal_use_exact_lp_reason() const;
2799  void _internal_set_use_exact_lp_reason(bool value);
2800  public:
2801 
2802  // optional int32 interleave_batch_size = 134 [default = 1];
2803  bool has_interleave_batch_size() const;
2804  private:
2805  bool _internal_has_interleave_batch_size() const;
2806  public:
2807  void clear_interleave_batch_size();
2808  ::PROTOBUF_NAMESPACE_ID::int32 interleave_batch_size() const;
2809  void set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2810  private:
2811  ::PROTOBUF_NAMESPACE_ID::int32 _internal_interleave_batch_size() const;
2812  void _internal_set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2813  public:
2814 
2815  // optional int32 max_presolve_iterations = 138 [default = 3];
2816  bool has_max_presolve_iterations() const;
2817  private:
2818  bool _internal_has_max_presolve_iterations() const;
2819  public:
2820  void clear_max_presolve_iterations();
2821  ::PROTOBUF_NAMESPACE_ID::int32 max_presolve_iterations() const;
2822  void set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value);
2823  private:
2824  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_presolve_iterations() const;
2825  void _internal_set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value);
2826  public:
2827 
2828  // optional int32 presolve_substitution_level = 147 [default = 1];
2829  bool has_presolve_substitution_level() const;
2830  private:
2831  bool _internal_has_presolve_substitution_level() const;
2832  public:
2833  void clear_presolve_substitution_level();
2834  ::PROTOBUF_NAMESPACE_ID::int32 presolve_substitution_level() const;
2835  void set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2836  private:
2837  ::PROTOBUF_NAMESPACE_ID::int32 _internal_presolve_substitution_level() const;
2838  void _internal_set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value);
2839  public:
2840 
2841  // optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
2842  bool has_merge_no_overlap_work_limit() const;
2843  private:
2844  bool _internal_has_merge_no_overlap_work_limit() const;
2845  public:
2846  void clear_merge_no_overlap_work_limit();
2847  double merge_no_overlap_work_limit() const;
2848  void set_merge_no_overlap_work_limit(double value);
2849  private:
2850  double _internal_merge_no_overlap_work_limit() const;
2851  void _internal_set_merge_no_overlap_work_limit(double value);
2852  public:
2853 
2854  // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
2855  bool has_merge_at_most_one_work_limit() const;
2856  private:
2857  bool _internal_has_merge_at_most_one_work_limit() const;
2858  public:
2859  void clear_merge_at_most_one_work_limit();
2860  double merge_at_most_one_work_limit() const;
2861  void set_merge_at_most_one_work_limit(double value);
2862  private:
2863  double _internal_merge_at_most_one_work_limit() const;
2864  void _internal_set_merge_at_most_one_work_limit(double value);
2865  public:
2866 
2867  // optional int32 max_all_diff_cut_size = 148 [default = 7];
2868  bool has_max_all_diff_cut_size() const;
2869  private:
2870  bool _internal_has_max_all_diff_cut_size() const;
2871  public:
2872  void clear_max_all_diff_cut_size();
2873  ::PROTOBUF_NAMESPACE_ID::int32 max_all_diff_cut_size() const;
2874  void set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2875  private:
2876  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_all_diff_cut_size() const;
2877  void _internal_set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value);
2878  public:
2879 
2880  // optional bool catch_sigint_signal = 135 [default = true];
2881  bool has_catch_sigint_signal() const;
2882  private:
2883  bool _internal_has_catch_sigint_signal() const;
2884  public:
2885  void clear_catch_sigint_signal();
2886  bool catch_sigint_signal() const;
2887  void set_catch_sigint_signal(bool value);
2888  private:
2889  bool _internal_catch_sigint_signal() const;
2890  void _internal_set_catch_sigint_signal(bool value);
2891  public:
2892 
2893  // optional bool use_implied_bounds = 144 [default = true];
2894  bool has_use_implied_bounds() const;
2895  private:
2896  bool _internal_has_use_implied_bounds() const;
2897  public:
2898  void clear_use_implied_bounds();
2899  bool use_implied_bounds() const;
2900  void set_use_implied_bounds(bool value);
2901  private:
2902  bool _internal_use_implied_bounds() const;
2903  void _internal_set_use_implied_bounds(bool value);
2904  public:
2905 
2906  // optional bool mip_automatically_scale_variables = 166 [default = true];
2907  bool has_mip_automatically_scale_variables() const;
2908  private:
2909  bool _internal_has_mip_automatically_scale_variables() const;
2910  public:
2911  void clear_mip_automatically_scale_variables();
2912  bool mip_automatically_scale_variables() const;
2913  void set_mip_automatically_scale_variables(bool value);
2914  private:
2915  bool _internal_mip_automatically_scale_variables() const;
2916  void _internal_set_mip_automatically_scale_variables(bool value);
2917  public:
2918 
2919  // optional bool add_zero_half_cuts = 169 [default = true];
2920  bool has_add_zero_half_cuts() const;
2921  private:
2922  bool _internal_has_add_zero_half_cuts() const;
2923  public:
2924  void clear_add_zero_half_cuts();
2925  bool add_zero_half_cuts() const;
2926  void set_add_zero_half_cuts(bool value);
2927  private:
2928  bool _internal_add_zero_half_cuts() const;
2929  void _internal_set_add_zero_half_cuts(bool value);
2930  public:
2931 
2932  // optional bool add_clique_cuts = 172 [default = true];
2933  bool has_add_clique_cuts() const;
2934  private:
2935  bool _internal_has_add_clique_cuts() const;
2936  public:
2937  void clear_add_clique_cuts();
2938  bool add_clique_cuts() const;
2939  void set_add_clique_cuts(bool value);
2940  private:
2941  bool _internal_add_clique_cuts() const;
2942  void _internal_set_add_clique_cuts(bool value);
2943  public:
2944 
2945  // optional bool add_lin_max_cuts = 152 [default = true];
2946  bool has_add_lin_max_cuts() const;
2947  private:
2948  bool _internal_has_add_lin_max_cuts() const;
2949  public:
2950  void clear_add_lin_max_cuts();
2951  bool add_lin_max_cuts() const;
2952  void set_add_lin_max_cuts(bool value);
2953  private:
2954  bool _internal_add_lin_max_cuts() const;
2955  void _internal_set_add_lin_max_cuts(bool value);
2956  public:
2957 
2958  // optional bool add_lp_constraints_lazily = 112 [default = true];
2959  bool has_add_lp_constraints_lazily() const;
2960  private:
2961  bool _internal_has_add_lp_constraints_lazily() const;
2962  public:
2963  void clear_add_lp_constraints_lazily();
2964  bool add_lp_constraints_lazily() const;
2965  void set_add_lp_constraints_lazily(bool value);
2966  private:
2967  bool _internal_add_lp_constraints_lazily() const;
2968  void _internal_set_add_lp_constraints_lazily(bool value);
2969  public:
2970 
2971  // optional int32 hint_conflict_limit = 153 [default = 10];
2972  bool has_hint_conflict_limit() const;
2973  private:
2974  bool _internal_has_hint_conflict_limit() const;
2975  public:
2976  void clear_hint_conflict_limit();
2977  ::PROTOBUF_NAMESPACE_ID::int32 hint_conflict_limit() const;
2978  void set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value);
2979  private:
2980  ::PROTOBUF_NAMESPACE_ID::int32 _internal_hint_conflict_limit() const;
2981  void _internal_set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value);
2982  public:
2983 
2984  // optional double cut_max_active_count_value = 155 [default = 10000000000];
2985  bool has_cut_max_active_count_value() const;
2986  private:
2987  bool _internal_has_cut_max_active_count_value() const;
2988  public:
2989  void clear_cut_max_active_count_value();
2990  double cut_max_active_count_value() const;
2991  void set_cut_max_active_count_value(double value);
2992  private:
2993  double _internal_cut_max_active_count_value() const;
2994  void _internal_set_cut_max_active_count_value(double value);
2995  public:
2996 
2997  // optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
2998  bool has_max_cut_rounds_at_level_zero() const;
2999  private:
3000  bool _internal_has_max_cut_rounds_at_level_zero() const;
3001  public:
3002  void clear_max_cut_rounds_at_level_zero();
3003  ::PROTOBUF_NAMESPACE_ID::int32 max_cut_rounds_at_level_zero() const;
3004  void set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value);
3005  private:
3006  ::PROTOBUF_NAMESPACE_ID::int32 _internal_max_cut_rounds_at_level_zero() const;
3007  void _internal_set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value);
3008  public:
3009 
3010  // optional bool expand_element_constraints = 140 [default = true];
3011  bool has_expand_element_constraints() const;
3012  private:
3013  bool _internal_has_expand_element_constraints() const;
3014  public:
3015  void clear_expand_element_constraints();
3016  bool expand_element_constraints() const;
3017  void set_expand_element_constraints(bool value);
3018  private:
3019  bool _internal_expand_element_constraints() const;
3020  void _internal_set_expand_element_constraints(bool value);
3021  public:
3022 
3023  // optional bool expand_automaton_constraints = 143 [default = true];
3024  bool has_expand_automaton_constraints() const;
3025  private:
3026  bool _internal_has_expand_automaton_constraints() const;
3027  public:
3028  void clear_expand_automaton_constraints();
3029  bool expand_automaton_constraints() const;
3030  void set_expand_automaton_constraints(bool value);
3031  private:
3032  bool _internal_expand_automaton_constraints() const;
3033  void _internal_set_expand_automaton_constraints(bool value);
3034  public:
3035 
3036  // optional bool expand_table_constraints = 158 [default = true];
3037  bool has_expand_table_constraints() const;
3038  private:
3039  bool _internal_has_expand_table_constraints() const;
3040  public:
3041  void clear_expand_table_constraints();
3042  bool expand_table_constraints() const;
3043  void set_expand_table_constraints(bool value);
3044  private:
3045  bool _internal_expand_table_constraints() const;
3046  void _internal_set_expand_table_constraints(bool value);
3047  public:
3048 
3049  // optional bool expand_reservoir_constraints = 182 [default = true];
3050  bool has_expand_reservoir_constraints() const;
3051  private:
3052  bool _internal_has_expand_reservoir_constraints() const;
3053  public:
3054  void clear_expand_reservoir_constraints();
3055  bool expand_reservoir_constraints() const;
3056  void set_expand_reservoir_constraints(bool value);
3057  private:
3058  bool _internal_expand_reservoir_constraints() const;
3059  void _internal_set_expand_reservoir_constraints(bool value);
3060  public:
3061 
3062  // optional double cut_active_count_decay = 156 [default = 0.8];
3063  bool has_cut_active_count_decay() const;
3064  private:
3065  bool _internal_has_cut_active_count_decay() const;
3066  public:
3067  void clear_cut_active_count_decay();
3068  double cut_active_count_decay() const;
3069  void set_cut_active_count_decay(double value);
3070  private:
3071  double _internal_cut_active_count_decay() const;
3072  void _internal_set_cut_active_count_decay(double value);
3073  public:
3074 
3075  // optional int32 cut_cleanup_target = 157 [default = 1000];
3076  bool has_cut_cleanup_target() const;
3077  private:
3078  bool _internal_has_cut_cleanup_target() const;
3079  public:
3080  void clear_cut_cleanup_target();
3081  ::PROTOBUF_NAMESPACE_ID::int32 cut_cleanup_target() const;
3082  void set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
3083  private:
3084  ::PROTOBUF_NAMESPACE_ID::int32 _internal_cut_cleanup_target() const;
3085  void _internal_set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value);
3086  public:
3087 
3088  // optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
3089  bool has_fp_rounding() const;
3090  private:
3091  bool _internal_has_fp_rounding() const;
3092  public:
3093  void clear_fp_rounding();
3094  ::operations_research::sat::SatParameters_FPRoundingMethod fp_rounding() const;
3095  void set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value);
3096  private:
3097  ::operations_research::sat::SatParameters_FPRoundingMethod _internal_fp_rounding() const;
3098  void _internal_set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value);
3099  public:
3100 
3101  // optional int32 polarity_rephase_increment = 168 [default = 1000];
3102  bool has_polarity_rephase_increment() const;
3103  private:
3104  bool _internal_has_polarity_rephase_increment() const;
3105  public:
3106  void clear_polarity_rephase_increment();
3107  ::PROTOBUF_NAMESPACE_ID::int32 polarity_rephase_increment() const;
3108  void set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
3109  private:
3110  ::PROTOBUF_NAMESPACE_ID::int32 _internal_polarity_rephase_increment() const;
3111  void _internal_set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value);
3112  public:
3113 
3114  // optional int32 symmetry_level = 183 [default = 2];
3115  bool has_symmetry_level() const;
3116  private:
3117  bool _internal_has_symmetry_level() const;
3118  public:
3119  void clear_symmetry_level();
3120  ::PROTOBUF_NAMESPACE_ID::int32 symmetry_level() const;
3121  void set_symmetry_level(::PROTOBUF_NAMESPACE_ID::int32 value);
3122  private:
3123  ::PROTOBUF_NAMESPACE_ID::int32 _internal_symmetry_level() const;
3124  void _internal_set_symmetry_level(::PROTOBUF_NAMESPACE_ID::int32 value);
3125  public:
3126 
3127  // @@protoc_insertion_point(class_scope:operations_research.sat.SatParameters)
3128  private:
3129  class _Internal;
3130 
3131  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3132  typedef void InternalArenaConstructable_;
3133  typedef void DestructorSkippable_;
3134  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<6> _has_bits_;
3135  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3136  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> restart_algorithms_;
3137  static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_default_restart_algorithms_;
3138  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_restart_algorithms_;
3139  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
3140  int preferred_variable_order_;
3141  int max_sat_assumption_order_;
3142  double random_branches_ratio_;
3143  double random_polarity_ratio_;
3144  int clause_cleanup_protection_;
3145  int clause_cleanup_ordering_;
3146  double strategy_change_increase_ratio_;
3147  ::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes_;
3148  int search_branching_;
3149  double initial_variables_activity_;
3150  bool use_overload_checker_in_cumulative_constraint_;
3151  bool use_timetable_edge_finding_in_cumulative_constraint_;
3152  bool only_add_cuts_at_level_zero_;
3153  bool add_knapsack_cuts_;
3154  bool use_erwa_heuristic_;
3155  bool also_bump_variables_in_conflict_reasons_;
3156  bool use_blocking_restart_;
3157  bool permute_variable_randomly_;
3158  ::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance_;
3159  bool use_pb_resolution_;
3160  bool minimize_reduction_during_pb_resolution_;
3161  bool cp_model_postsolve_with_full_solver_;
3162  bool use_sat_inprocessing_;
3163  bool optimize_with_core_;
3164  bool optimize_with_max_hs_;
3165  bool enumerate_all_solutions_;
3166  bool keep_all_feasible_solutions_in_presolve_;
3167  bool reduce_memory_usage_in_interleave_mode_;
3168  bool use_lns_only_;
3169  bool lns_focus_on_decision_variables_;
3170  bool use_relaxation_lns_;
3171  bool diversify_lns_params_;
3172  bool randomize_search_;
3173  bool use_branching_in_lp_;
3174  bool use_combined_no_overlap_;
3175  bool fill_tightened_domains_in_response_;
3176  bool stop_after_first_solution_;
3177  bool stop_after_presolve_;
3178  bool interleave_search_;
3179  bool expand_alldiff_constraints_;
3180  bool disable_constraint_expansion_;
3181  bool presolve_extract_integer_enforcement_;
3182  bool max_sat_reverse_assumption_order_;
3183  ::PROTOBUF_NAMESPACE_ID::int64 probing_period_at_root_;
3184  bool permute_presolve_constraint_order_;
3185  bool use_absl_random_;
3186  bool log_search_progress_;
3187  bool fill_logs_in_response_;
3188  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_max_num_presolve_operations_;
3189  double absolute_gap_limit_;
3190  double relative_gap_limit_;
3191  bool repair_hint_;
3192  bool exploit_best_solution_;
3193  bool exploit_relaxation_solution_;
3194  bool use_probing_search_;
3195  bool polish_lp_solution_;
3196  bool convert_intervals_;
3197  int initial_polarity_;
3198  int minimization_algorithm_;
3199  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period_;
3200  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target_;
3201  double variable_activity_decay_;
3202  double max_variable_activity_value_;
3203  double clause_activity_decay_;
3204  double max_clause_activity_value_;
3205  double glucose_max_decay_;
3206  double glucose_decay_increment_;
3207  ::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period_;
3208  ::PROTOBUF_NAMESPACE_ID::int32 restart_period_;
3209  ::PROTOBUF_NAMESPACE_ID::int32 random_seed_;
3210  int binary_minimization_algorithm_;
3211  double max_time_in_seconds_;
3212  ::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts_;
3213  ::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb_;
3214  bool use_phase_saving_;
3215  bool subsumption_during_conflict_analysis_;
3216  bool treat_binary_clauses_separately_;
3217  bool count_assumption_levels_in_lbd_;
3218  ::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment_;
3219  double pb_cleanup_ratio_;
3220  int max_sat_stratification_;
3221  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold_;
3222  double presolve_probing_deterministic_time_limit_;
3223  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight_;
3224  ::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound_;
3225  double restart_dl_average_ratio_;
3226  ::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size_;
3227  bool use_optimization_hints_;
3228  bool minimize_core_;
3229  bool find_multiple_cores_;
3230  bool cover_optimization_;
3231  double blocking_restart_multiplier_;
3232  double max_deterministic_time_;
3233  ::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size_;
3234  ::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold_;
3235  double restart_lbd_average_ratio_;
3236  bool presolve_blocked_clause_;
3237  bool presolve_use_bva_;
3238  bool cp_model_presolve_;
3239  bool cp_model_use_sat_presolve_;
3240  ::PROTOBUF_NAMESPACE_ID::int32 linearization_level_;
3241  ::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts_;
3242  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period_;
3243  ::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions_;
3244  bool use_precedences_in_disjunctive_constraint_;
3245  bool use_disjunctive_constraint_in_cumulative_constraint_;
3246  bool add_cg_cuts_;
3247  bool add_mir_cuts_;
3248  ::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts_;
3249  ::PROTOBUF_NAMESPACE_ID::int32 num_search_workers_;
3250  ::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level_;
3251  ::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level_;
3252  bool exploit_integer_lp_solution_;
3253  bool exploit_all_lp_solution_;
3254  bool exploit_objective_;
3255  bool instantiate_all_variables_;
3256  ::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling_;
3257  double min_orthogonality_for_lp_constraints_;
3258  ::PROTOBUF_NAMESPACE_ID::int32 max_consecutive_inactive_count_;
3259  ::PROTOBUF_NAMESPACE_ID::int32 new_constraints_batch_size_;
3260  ::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold_;
3261  double mip_max_bound_;
3262  double mip_var_scaling_;
3263  double mip_wanted_precision_;
3264  bool auto_detect_greater_than_at_least_one_of_;
3265  bool share_objective_bounds_;
3266  bool share_level_zero_bounds_;
3267  bool lns_expand_intervals_in_constraint_graph_;
3268  ::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent_;
3269  double mip_check_precision_;
3270  bool use_rins_lns_;
3271  bool use_feasibility_pump_;
3272  bool use_optional_variables_;
3273  bool use_exact_lp_reason_;
3274  ::PROTOBUF_NAMESPACE_ID::int32 interleave_batch_size_;
3275  ::PROTOBUF_NAMESPACE_ID::int32 max_presolve_iterations_;
3276  ::PROTOBUF_NAMESPACE_ID::int32 presolve_substitution_level_;
3277  double merge_no_overlap_work_limit_;
3278  double merge_at_most_one_work_limit_;
3279  ::PROTOBUF_NAMESPACE_ID::int32 max_all_diff_cut_size_;
3280  bool catch_sigint_signal_;
3281  bool use_implied_bounds_;
3282  bool mip_automatically_scale_variables_;
3283  bool add_zero_half_cuts_;
3284  bool add_clique_cuts_;
3285  bool add_lin_max_cuts_;
3286  bool add_lp_constraints_lazily_;
3287  ::PROTOBUF_NAMESPACE_ID::int32 hint_conflict_limit_;
3288  double cut_max_active_count_value_;
3289  ::PROTOBUF_NAMESPACE_ID::int32 max_cut_rounds_at_level_zero_;
3290  bool expand_element_constraints_;
3291  bool expand_automaton_constraints_;
3292  bool expand_table_constraints_;
3293  bool expand_reservoir_constraints_;
3294  double cut_active_count_decay_;
3295  ::PROTOBUF_NAMESPACE_ID::int32 cut_cleanup_target_;
3296  int fp_rounding_;
3297  ::PROTOBUF_NAMESPACE_ID::int32 polarity_rephase_increment_;
3298  ::PROTOBUF_NAMESPACE_ID::int32 symmetry_level_;
3299  friend struct ::TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto;
3300 };
3301 // ===================================================================
3302 
3303 
3304 // ===================================================================
3305 
3306 #ifdef __GNUC__
3307  #pragma GCC diagnostic push
3308  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3309 #endif // __GNUC__
3310 // SatParameters
3311 
3312 // optional string name = 171 [default = ""];
3313 inline bool SatParameters::_internal_has_name() const {
3314  bool value = (_has_bits_[0] & 0x00000002u) != 0;
3315  return value;
3316 }
3317 inline bool SatParameters::has_name() const {
3318  return _internal_has_name();
3319 }
3320 inline void SatParameters::clear_name() {
3321  name_.ClearToEmpty();
3322  _has_bits_[0] &= ~0x00000002u;
3323 }
3324 inline const std::string& SatParameters::name() const {
3325  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.name)
3326  return _internal_name();
3327 }
3328 inline void SatParameters::set_name(const std::string& value) {
3329  _internal_set_name(value);
3330  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.name)
3331 }
3332 inline std::string* SatParameters::mutable_name() {
3333  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.name)
3334  return _internal_mutable_name();
3335 }
3336 inline const std::string& SatParameters::_internal_name() const {
3337  return name_.Get();
3338 }
3339 inline void SatParameters::_internal_set_name(const std::string& value) {
3340  _has_bits_[0] |= 0x00000002u;
3341  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
3342 }
3343 inline void SatParameters::set_name(std::string&& value) {
3344  _has_bits_[0] |= 0x00000002u;
3345  name_.Set(
3346  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
3347  // @@protoc_insertion_point(field_set_rvalue:operations_research.sat.SatParameters.name)
3348 }
3349 inline void SatParameters::set_name(const char* value) {
3350  GOOGLE_DCHECK(value != nullptr);
3351  _has_bits_[0] |= 0x00000002u;
3352  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
3353  // @@protoc_insertion_point(field_set_char:operations_research.sat.SatParameters.name)
3354 }
3355 inline void SatParameters::set_name(const char* value,
3356  size_t size) {
3357  _has_bits_[0] |= 0x00000002u;
3358  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
3359  reinterpret_cast<const char*>(value), size), GetArena());
3360  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.SatParameters.name)
3361 }
3362 inline std::string* SatParameters::_internal_mutable_name() {
3363  _has_bits_[0] |= 0x00000002u;
3364  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
3365 }
3366 inline std::string* SatParameters::release_name() {
3367  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.name)
3368  if (!_internal_has_name()) {
3369  return nullptr;
3370  }
3371  _has_bits_[0] &= ~0x00000002u;
3372  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
3373 }
3374 inline void SatParameters::set_allocated_name(std::string* name) {
3375  if (name != nullptr) {
3376  _has_bits_[0] |= 0x00000002u;
3377  } else {
3378  _has_bits_[0] &= ~0x00000002u;
3379  }
3380  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
3381  GetArena());
3382  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.name)
3383 }
3384 
3385 // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
3386 inline bool SatParameters::_internal_has_preferred_variable_order() const {
3387  bool value = (_has_bits_[0] & 0x00000004u) != 0;
3388  return value;
3389 }
3390 inline bool SatParameters::has_preferred_variable_order() const {
3391  return _internal_has_preferred_variable_order();
3392 }
3393 inline void SatParameters::clear_preferred_variable_order() {
3394  preferred_variable_order_ = 0;
3395  _has_bits_[0] &= ~0x00000004u;
3396 }
3397 inline ::operations_research::sat::SatParameters_VariableOrder SatParameters::_internal_preferred_variable_order() const {
3398  return static_cast< ::operations_research::sat::SatParameters_VariableOrder >(preferred_variable_order_);
3399 }
3400 inline ::operations_research::sat::SatParameters_VariableOrder SatParameters::preferred_variable_order() const {
3401  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.preferred_variable_order)
3402  return _internal_preferred_variable_order();
3403 }
3404 inline void SatParameters::_internal_set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value) {
3405  assert(::operations_research::sat::SatParameters_VariableOrder_IsValid(value));
3406  _has_bits_[0] |= 0x00000004u;
3407  preferred_variable_order_ = value;
3408 }
3409 inline void SatParameters::set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value) {
3410  _internal_set_preferred_variable_order(value);
3411  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.preferred_variable_order)
3412 }
3413 
3414 // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
3415 inline bool SatParameters::_internal_has_initial_polarity() const {
3416  bool value = (_has_bits_[1] & 0x08000000u) != 0;
3417  return value;
3418 }
3419 inline bool SatParameters::has_initial_polarity() const {
3420  return _internal_has_initial_polarity();
3421 }
3422 inline void SatParameters::clear_initial_polarity() {
3423  initial_polarity_ = 1;
3424  _has_bits_[1] &= ~0x08000000u;
3425 }
3426 inline ::operations_research::sat::SatParameters_Polarity SatParameters::_internal_initial_polarity() const {
3427  return static_cast< ::operations_research::sat::SatParameters_Polarity >(initial_polarity_);
3428 }
3429 inline ::operations_research::sat::SatParameters_Polarity SatParameters::initial_polarity() const {
3430  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.initial_polarity)
3431  return _internal_initial_polarity();
3432 }
3433 inline void SatParameters::_internal_set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
3434  assert(::operations_research::sat::SatParameters_Polarity_IsValid(value));
3435  _has_bits_[1] |= 0x08000000u;
3436  initial_polarity_ = value;
3437 }
3438 inline void SatParameters::set_initial_polarity(::operations_research::sat::SatParameters_Polarity value) {
3439  _internal_set_initial_polarity(value);
3440  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.initial_polarity)
3441 }
3442 
3443 // optional bool use_phase_saving = 44 [default = true];
3444 inline bool SatParameters::_internal_has_use_phase_saving() const {
3445  bool value = (_has_bits_[2] & 0x00001000u) != 0;
3446  return value;
3447 }
3448 inline bool SatParameters::has_use_phase_saving() const {
3449  return _internal_has_use_phase_saving();
3450 }
3451 inline void SatParameters::clear_use_phase_saving() {
3452  use_phase_saving_ = true;
3453  _has_bits_[2] &= ~0x00001000u;
3454 }
3455 inline bool SatParameters::_internal_use_phase_saving() const {
3456  return use_phase_saving_;
3457 }
3458 inline bool SatParameters::use_phase_saving() const {
3459  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_phase_saving)
3460  return _internal_use_phase_saving();
3461 }
3462 inline void SatParameters::_internal_set_use_phase_saving(bool value) {
3463  _has_bits_[2] |= 0x00001000u;
3464  use_phase_saving_ = value;
3465 }
3466 inline void SatParameters::set_use_phase_saving(bool value) {
3467  _internal_set_use_phase_saving(value);
3468  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_phase_saving)
3469 }
3470 
3471 // optional int32 polarity_rephase_increment = 168 [default = 1000];
3472 inline bool SatParameters::_internal_has_polarity_rephase_increment() const {
3473  bool value = (_has_bits_[4] & 0x80000000u) != 0;
3474  return value;
3475 }
3476 inline bool SatParameters::has_polarity_rephase_increment() const {
3477  return _internal_has_polarity_rephase_increment();
3478 }
3479 inline void SatParameters::clear_polarity_rephase_increment() {
3480  polarity_rephase_increment_ = 1000;
3481  _has_bits_[4] &= ~0x80000000u;
3482 }
3483 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_polarity_rephase_increment() const {
3484  return polarity_rephase_increment_;
3485 }
3486 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::polarity_rephase_increment() const {
3487  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.polarity_rephase_increment)
3488  return _internal_polarity_rephase_increment();
3489 }
3490 inline void SatParameters::_internal_set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
3491  _has_bits_[4] |= 0x80000000u;
3492  polarity_rephase_increment_ = value;
3493 }
3494 inline void SatParameters::set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
3495  _internal_set_polarity_rephase_increment(value);
3496  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.polarity_rephase_increment)
3497 }
3498 
3499 // optional double random_polarity_ratio = 45 [default = 0];
3500 inline bool SatParameters::_internal_has_random_polarity_ratio() const {
3501  bool value = (_has_bits_[0] & 0x00000020u) != 0;
3502  return value;
3503 }
3504 inline bool SatParameters::has_random_polarity_ratio() const {
3505  return _internal_has_random_polarity_ratio();
3506 }
3507 inline void SatParameters::clear_random_polarity_ratio() {
3508  random_polarity_ratio_ = 0;
3509  _has_bits_[0] &= ~0x00000020u;
3510 }
3511 inline double SatParameters::_internal_random_polarity_ratio() const {
3512  return random_polarity_ratio_;
3513 }
3514 inline double SatParameters::random_polarity_ratio() const {
3515  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_polarity_ratio)
3516  return _internal_random_polarity_ratio();
3517 }
3518 inline void SatParameters::_internal_set_random_polarity_ratio(double value) {
3519  _has_bits_[0] |= 0x00000020u;
3520  random_polarity_ratio_ = value;
3521 }
3522 inline void SatParameters::set_random_polarity_ratio(double value) {
3523  _internal_set_random_polarity_ratio(value);
3524  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_polarity_ratio)
3525 }
3526 
3527 // optional double random_branches_ratio = 32 [default = 0];
3528 inline bool SatParameters::_internal_has_random_branches_ratio() const {
3529  bool value = (_has_bits_[0] & 0x00000010u) != 0;
3530  return value;
3531 }
3532 inline bool SatParameters::has_random_branches_ratio() const {
3533  return _internal_has_random_branches_ratio();
3534 }
3535 inline void SatParameters::clear_random_branches_ratio() {
3536  random_branches_ratio_ = 0;
3537  _has_bits_[0] &= ~0x00000010u;
3538 }
3539 inline double SatParameters::_internal_random_branches_ratio() const {
3540  return random_branches_ratio_;
3541 }
3542 inline double SatParameters::random_branches_ratio() const {
3543  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_branches_ratio)
3544  return _internal_random_branches_ratio();
3545 }
3546 inline void SatParameters::_internal_set_random_branches_ratio(double value) {
3547  _has_bits_[0] |= 0x00000010u;
3548  random_branches_ratio_ = value;
3549 }
3550 inline void SatParameters::set_random_branches_ratio(double value) {
3551  _internal_set_random_branches_ratio(value);
3552  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_branches_ratio)
3553 }
3554 
3555 // optional bool use_erwa_heuristic = 75 [default = false];
3556 inline bool SatParameters::_internal_has_use_erwa_heuristic() const {
3557  bool value = (_has_bits_[0] & 0x00010000u) != 0;
3558  return value;
3559 }
3560 inline bool SatParameters::has_use_erwa_heuristic() const {
3561  return _internal_has_use_erwa_heuristic();
3562 }
3563 inline void SatParameters::clear_use_erwa_heuristic() {
3564  use_erwa_heuristic_ = false;
3565  _has_bits_[0] &= ~0x00010000u;
3566 }
3567 inline bool SatParameters::_internal_use_erwa_heuristic() const {
3568  return use_erwa_heuristic_;
3569 }
3570 inline bool SatParameters::use_erwa_heuristic() const {
3571  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_erwa_heuristic)
3572  return _internal_use_erwa_heuristic();
3573 }
3574 inline void SatParameters::_internal_set_use_erwa_heuristic(bool value) {
3575  _has_bits_[0] |= 0x00010000u;
3576  use_erwa_heuristic_ = value;
3577 }
3578 inline void SatParameters::set_use_erwa_heuristic(bool value) {
3579  _internal_set_use_erwa_heuristic(value);
3580  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_erwa_heuristic)
3581 }
3582 
3583 // optional double initial_variables_activity = 76 [default = 0];
3584 inline bool SatParameters::_internal_has_initial_variables_activity() const {
3585  bool value = (_has_bits_[0] & 0x00000800u) != 0;
3586  return value;
3587 }
3588 inline bool SatParameters::has_initial_variables_activity() const {
3589  return _internal_has_initial_variables_activity();
3590 }
3591 inline void SatParameters::clear_initial_variables_activity() {
3592  initial_variables_activity_ = 0;
3593  _has_bits_[0] &= ~0x00000800u;
3594 }
3595 inline double SatParameters::_internal_initial_variables_activity() const {
3596  return initial_variables_activity_;
3597 }
3598 inline double SatParameters::initial_variables_activity() const {
3599  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.initial_variables_activity)
3600  return _internal_initial_variables_activity();
3601 }
3602 inline void SatParameters::_internal_set_initial_variables_activity(double value) {
3603  _has_bits_[0] |= 0x00000800u;
3604  initial_variables_activity_ = value;
3605 }
3606 inline void SatParameters::set_initial_variables_activity(double value) {
3607  _internal_set_initial_variables_activity(value);
3608  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.initial_variables_activity)
3609 }
3610 
3611 // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
3612 inline bool SatParameters::_internal_has_also_bump_variables_in_conflict_reasons() const {
3613  bool value = (_has_bits_[0] & 0x00020000u) != 0;
3614  return value;
3615 }
3616 inline bool SatParameters::has_also_bump_variables_in_conflict_reasons() const {
3617  return _internal_has_also_bump_variables_in_conflict_reasons();
3618 }
3619 inline void SatParameters::clear_also_bump_variables_in_conflict_reasons() {
3620  also_bump_variables_in_conflict_reasons_ = false;
3621  _has_bits_[0] &= ~0x00020000u;
3622 }
3623 inline bool SatParameters::_internal_also_bump_variables_in_conflict_reasons() const {
3624  return also_bump_variables_in_conflict_reasons_;
3625 }
3626 inline bool SatParameters::also_bump_variables_in_conflict_reasons() const {
3627  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.also_bump_variables_in_conflict_reasons)
3628  return _internal_also_bump_variables_in_conflict_reasons();
3629 }
3630 inline void SatParameters::_internal_set_also_bump_variables_in_conflict_reasons(bool value) {
3631  _has_bits_[0] |= 0x00020000u;
3632  also_bump_variables_in_conflict_reasons_ = value;
3633 }
3634 inline void SatParameters::set_also_bump_variables_in_conflict_reasons(bool value) {
3635  _internal_set_also_bump_variables_in_conflict_reasons(value);
3636  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.also_bump_variables_in_conflict_reasons)
3637 }
3638 
3639 // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
3640 inline bool SatParameters::_internal_has_minimization_algorithm() const {
3641  bool value = (_has_bits_[1] & 0x10000000u) != 0;
3642  return value;
3643 }
3644 inline bool SatParameters::has_minimization_algorithm() const {
3645  return _internal_has_minimization_algorithm();
3646 }
3647 inline void SatParameters::clear_minimization_algorithm() {
3648  minimization_algorithm_ = 2;
3649  _has_bits_[1] &= ~0x10000000u;
3650 }
3651 inline ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm SatParameters::_internal_minimization_algorithm() const {
3652  return static_cast< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm >(minimization_algorithm_);
3653 }
3654 inline ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm SatParameters::minimization_algorithm() const {
3655  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimization_algorithm)
3656  return _internal_minimization_algorithm();
3657 }
3658 inline void SatParameters::_internal_set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
3659  assert(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_IsValid(value));
3660  _has_bits_[1] |= 0x10000000u;
3661  minimization_algorithm_ = value;
3662 }
3663 inline void SatParameters::set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value) {
3664  _internal_set_minimization_algorithm(value);
3665  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimization_algorithm)
3666 }
3667 
3668 // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
3669 inline bool SatParameters::_internal_has_binary_minimization_algorithm() const {
3670  bool value = (_has_bits_[2] & 0x00000100u) != 0;
3671  return value;
3672 }
3673 inline bool SatParameters::has_binary_minimization_algorithm() const {
3674  return _internal_has_binary_minimization_algorithm();
3675 }
3676 inline void SatParameters::clear_binary_minimization_algorithm() {
3677  binary_minimization_algorithm_ = 1;
3678  _has_bits_[2] &= ~0x00000100u;
3679 }
3680 inline ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm SatParameters::_internal_binary_minimization_algorithm() const {
3681  return static_cast< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm >(binary_minimization_algorithm_);
3682 }
3683 inline ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm SatParameters::binary_minimization_algorithm() const {
3684  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.binary_minimization_algorithm)
3685  return _internal_binary_minimization_algorithm();
3686 }
3687 inline void SatParameters::_internal_set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
3688  assert(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_IsValid(value));
3689  _has_bits_[2] |= 0x00000100u;
3690  binary_minimization_algorithm_ = value;
3691 }
3692 inline void SatParameters::set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value) {
3693  _internal_set_binary_minimization_algorithm(value);
3694  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.binary_minimization_algorithm)
3695 }
3696 
3697 // optional bool subsumption_during_conflict_analysis = 56 [default = true];
3698 inline bool SatParameters::_internal_has_subsumption_during_conflict_analysis() const {
3699  bool value = (_has_bits_[2] & 0x00002000u) != 0;
3700  return value;
3701 }
3702 inline bool SatParameters::has_subsumption_during_conflict_analysis() const {
3703  return _internal_has_subsumption_during_conflict_analysis();
3704 }
3705 inline void SatParameters::clear_subsumption_during_conflict_analysis() {
3706  subsumption_during_conflict_analysis_ = true;
3707  _has_bits_[2] &= ~0x00002000u;
3708 }
3709 inline bool SatParameters::_internal_subsumption_during_conflict_analysis() const {
3710  return subsumption_during_conflict_analysis_;
3711 }
3712 inline bool SatParameters::subsumption_during_conflict_analysis() const {
3713  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.subsumption_during_conflict_analysis)
3714  return _internal_subsumption_during_conflict_analysis();
3715 }
3716 inline void SatParameters::_internal_set_subsumption_during_conflict_analysis(bool value) {
3717  _has_bits_[2] |= 0x00002000u;
3718  subsumption_during_conflict_analysis_ = value;
3719 }
3720 inline void SatParameters::set_subsumption_during_conflict_analysis(bool value) {
3721  _internal_set_subsumption_during_conflict_analysis(value);
3722  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.subsumption_during_conflict_analysis)
3723 }
3724 
3725 // optional int32 clause_cleanup_period = 11 [default = 10000];
3726 inline bool SatParameters::_internal_has_clause_cleanup_period() const {
3727  bool value = (_has_bits_[1] & 0x20000000u) != 0;
3728  return value;
3729 }
3730 inline bool SatParameters::has_clause_cleanup_period() const {
3731  return _internal_has_clause_cleanup_period();
3732 }
3733 inline void SatParameters::clear_clause_cleanup_period() {
3734  clause_cleanup_period_ = 10000;
3735  _has_bits_[1] &= ~0x20000000u;
3736 }
3737 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_period() const {
3738  return clause_cleanup_period_;
3739 }
3740 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_period() const {
3741  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_period)
3742  return _internal_clause_cleanup_period();
3743 }
3744 inline void SatParameters::_internal_set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3745  _has_bits_[1] |= 0x20000000u;
3746  clause_cleanup_period_ = value;
3747 }
3748 inline void SatParameters::set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3749  _internal_set_clause_cleanup_period(value);
3750  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_period)
3751 }
3752 
3753 // optional int32 clause_cleanup_target = 13 [default = 10000];
3754 inline bool SatParameters::_internal_has_clause_cleanup_target() const {
3755  bool value = (_has_bits_[1] & 0x40000000u) != 0;
3756  return value;
3757 }
3758 inline bool SatParameters::has_clause_cleanup_target() const {
3759  return _internal_has_clause_cleanup_target();
3760 }
3761 inline void SatParameters::clear_clause_cleanup_target() {
3762  clause_cleanup_target_ = 10000;
3763  _has_bits_[1] &= ~0x40000000u;
3764 }
3765 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_target() const {
3766  return clause_cleanup_target_;
3767 }
3768 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_target() const {
3769  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_target)
3770  return _internal_clause_cleanup_target();
3771 }
3772 inline void SatParameters::_internal_set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
3773  _has_bits_[1] |= 0x40000000u;
3774  clause_cleanup_target_ = value;
3775 }
3776 inline void SatParameters::set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
3777  _internal_set_clause_cleanup_target(value);
3778  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_target)
3779 }
3780 
3781 // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
3782 inline bool SatParameters::_internal_has_clause_cleanup_protection() const {
3783  bool value = (_has_bits_[0] & 0x00000040u) != 0;
3784  return value;
3785 }
3786 inline bool SatParameters::has_clause_cleanup_protection() const {
3787  return _internal_has_clause_cleanup_protection();
3788 }
3789 inline void SatParameters::clear_clause_cleanup_protection() {
3790  clause_cleanup_protection_ = 0;
3791  _has_bits_[0] &= ~0x00000040u;
3792 }
3793 inline ::operations_research::sat::SatParameters_ClauseProtection SatParameters::_internal_clause_cleanup_protection() const {
3794  return static_cast< ::operations_research::sat::SatParameters_ClauseProtection >(clause_cleanup_protection_);
3795 }
3796 inline ::operations_research::sat::SatParameters_ClauseProtection SatParameters::clause_cleanup_protection() const {
3797  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_protection)
3798  return _internal_clause_cleanup_protection();
3799 }
3800 inline void SatParameters::_internal_set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value) {
3801  assert(::operations_research::sat::SatParameters_ClauseProtection_IsValid(value));
3802  _has_bits_[0] |= 0x00000040u;
3803  clause_cleanup_protection_ = value;
3804 }
3805 inline void SatParameters::set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value) {
3806  _internal_set_clause_cleanup_protection(value);
3807  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_protection)
3808 }
3809 
3810 // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
3811 inline bool SatParameters::_internal_has_clause_cleanup_lbd_bound() const {
3812  bool value = (_has_bits_[2] & 0x00400000u) != 0;
3813  return value;
3814 }
3815 inline bool SatParameters::has_clause_cleanup_lbd_bound() const {
3816  return _internal_has_clause_cleanup_lbd_bound();
3817 }
3818 inline void SatParameters::clear_clause_cleanup_lbd_bound() {
3819  clause_cleanup_lbd_bound_ = 5;
3820  _has_bits_[2] &= ~0x00400000u;
3821 }
3822 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_clause_cleanup_lbd_bound() const {
3823  return clause_cleanup_lbd_bound_;
3824 }
3825 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::clause_cleanup_lbd_bound() const {
3826  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_lbd_bound)
3827  return _internal_clause_cleanup_lbd_bound();
3828 }
3829 inline void SatParameters::_internal_set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value) {
3830  _has_bits_[2] |= 0x00400000u;
3831  clause_cleanup_lbd_bound_ = value;
3832 }
3833 inline void SatParameters::set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value) {
3834  _internal_set_clause_cleanup_lbd_bound(value);
3835  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_lbd_bound)
3836 }
3837 
3838 // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
3839 inline bool SatParameters::_internal_has_clause_cleanup_ordering() const {
3840  bool value = (_has_bits_[0] & 0x00000080u) != 0;
3841  return value;
3842 }
3843 inline bool SatParameters::has_clause_cleanup_ordering() const {
3844  return _internal_has_clause_cleanup_ordering();
3845 }
3846 inline void SatParameters::clear_clause_cleanup_ordering() {
3847  clause_cleanup_ordering_ = 0;
3848  _has_bits_[0] &= ~0x00000080u;
3849 }
3850 inline ::operations_research::sat::SatParameters_ClauseOrdering SatParameters::_internal_clause_cleanup_ordering() const {
3851  return static_cast< ::operations_research::sat::SatParameters_ClauseOrdering >(clause_cleanup_ordering_);
3852 }
3853 inline ::operations_research::sat::SatParameters_ClauseOrdering SatParameters::clause_cleanup_ordering() const {
3854  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_cleanup_ordering)
3855  return _internal_clause_cleanup_ordering();
3856 }
3857 inline void SatParameters::_internal_set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
3858  assert(::operations_research::sat::SatParameters_ClauseOrdering_IsValid(value));
3859  _has_bits_[0] |= 0x00000080u;
3860  clause_cleanup_ordering_ = value;
3861 }
3862 inline void SatParameters::set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value) {
3863  _internal_set_clause_cleanup_ordering(value);
3864  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_cleanup_ordering)
3865 }
3866 
3867 // optional int32 pb_cleanup_increment = 46 [default = 200];
3868 inline bool SatParameters::_internal_has_pb_cleanup_increment() const {
3869  bool value = (_has_bits_[2] & 0x00010000u) != 0;
3870  return value;
3871 }
3872 inline bool SatParameters::has_pb_cleanup_increment() const {
3873  return _internal_has_pb_cleanup_increment();
3874 }
3875 inline void SatParameters::clear_pb_cleanup_increment() {
3876  pb_cleanup_increment_ = 200;
3877  _has_bits_[2] &= ~0x00010000u;
3878 }
3879 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_pb_cleanup_increment() const {
3880  return pb_cleanup_increment_;
3881 }
3882 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::pb_cleanup_increment() const {
3883  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pb_cleanup_increment)
3884  return _internal_pb_cleanup_increment();
3885 }
3886 inline void SatParameters::_internal_set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
3887  _has_bits_[2] |= 0x00010000u;
3888  pb_cleanup_increment_ = value;
3889 }
3890 inline void SatParameters::set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value) {
3891  _internal_set_pb_cleanup_increment(value);
3892  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pb_cleanup_increment)
3893 }
3894 
3895 // optional double pb_cleanup_ratio = 47 [default = 0.5];
3896 inline bool SatParameters::_internal_has_pb_cleanup_ratio() const {
3897  bool value = (_has_bits_[2] & 0x00020000u) != 0;
3898  return value;
3899 }
3900 inline bool SatParameters::has_pb_cleanup_ratio() const {
3901  return _internal_has_pb_cleanup_ratio();
3902 }
3903 inline void SatParameters::clear_pb_cleanup_ratio() {
3904  pb_cleanup_ratio_ = 0.5;
3905  _has_bits_[2] &= ~0x00020000u;
3906 }
3907 inline double SatParameters::_internal_pb_cleanup_ratio() const {
3908  return pb_cleanup_ratio_;
3909 }
3910 inline double SatParameters::pb_cleanup_ratio() const {
3911  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pb_cleanup_ratio)
3912  return _internal_pb_cleanup_ratio();
3913 }
3914 inline void SatParameters::_internal_set_pb_cleanup_ratio(double value) {
3915  _has_bits_[2] |= 0x00020000u;
3916  pb_cleanup_ratio_ = value;
3917 }
3918 inline void SatParameters::set_pb_cleanup_ratio(double value) {
3919  _internal_set_pb_cleanup_ratio(value);
3920  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pb_cleanup_ratio)
3921 }
3922 
3923 // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
3924 inline bool SatParameters::_internal_has_minimize_with_propagation_restart_period() const {
3925  bool value = (_has_bits_[3] & 0x00000100u) != 0;
3926  return value;
3927 }
3928 inline bool SatParameters::has_minimize_with_propagation_restart_period() const {
3929  return _internal_has_minimize_with_propagation_restart_period();
3930 }
3931 inline void SatParameters::clear_minimize_with_propagation_restart_period() {
3932  minimize_with_propagation_restart_period_ = 10;
3933  _has_bits_[3] &= ~0x00000100u;
3934 }
3935 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_minimize_with_propagation_restart_period() const {
3936  return minimize_with_propagation_restart_period_;
3937 }
3938 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::minimize_with_propagation_restart_period() const {
3939  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_with_propagation_restart_period)
3940  return _internal_minimize_with_propagation_restart_period();
3941 }
3942 inline void SatParameters::_internal_set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3943  _has_bits_[3] |= 0x00000100u;
3944  minimize_with_propagation_restart_period_ = value;
3945 }
3946 inline void SatParameters::set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
3947  _internal_set_minimize_with_propagation_restart_period(value);
3948  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_with_propagation_restart_period)
3949 }
3950 
3951 // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
3952 inline bool SatParameters::_internal_has_minimize_with_propagation_num_decisions() const {
3953  bool value = (_has_bits_[3] & 0x00000200u) != 0;
3954  return value;
3955 }
3956 inline bool SatParameters::has_minimize_with_propagation_num_decisions() const {
3957  return _internal_has_minimize_with_propagation_num_decisions();
3958 }
3959 inline void SatParameters::clear_minimize_with_propagation_num_decisions() {
3960  minimize_with_propagation_num_decisions_ = 1000;
3961  _has_bits_[3] &= ~0x00000200u;
3962 }
3963 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_minimize_with_propagation_num_decisions() const {
3964  return minimize_with_propagation_num_decisions_;
3965 }
3966 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::minimize_with_propagation_num_decisions() const {
3967  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_with_propagation_num_decisions)
3968  return _internal_minimize_with_propagation_num_decisions();
3969 }
3970 inline void SatParameters::_internal_set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value) {
3971  _has_bits_[3] |= 0x00000200u;
3972  minimize_with_propagation_num_decisions_ = value;
3973 }
3974 inline void SatParameters::set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value) {
3975  _internal_set_minimize_with_propagation_num_decisions(value);
3976  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_with_propagation_num_decisions)
3977 }
3978 
3979 // optional double variable_activity_decay = 15 [default = 0.8];
3980 inline bool SatParameters::_internal_has_variable_activity_decay() const {
3981  bool value = (_has_bits_[1] & 0x80000000u) != 0;
3982  return value;
3983 }
3984 inline bool SatParameters::has_variable_activity_decay() const {
3985  return _internal_has_variable_activity_decay();
3986 }
3987 inline void SatParameters::clear_variable_activity_decay() {
3988  variable_activity_decay_ = 0.8;
3989  _has_bits_[1] &= ~0x80000000u;
3990 }
3991 inline double SatParameters::_internal_variable_activity_decay() const {
3992  return variable_activity_decay_;
3993 }
3994 inline double SatParameters::variable_activity_decay() const {
3995  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.variable_activity_decay)
3996  return _internal_variable_activity_decay();
3997 }
3998 inline void SatParameters::_internal_set_variable_activity_decay(double value) {
3999  _has_bits_[1] |= 0x80000000u;
4000  variable_activity_decay_ = value;
4001 }
4002 inline void SatParameters::set_variable_activity_decay(double value) {
4003  _internal_set_variable_activity_decay(value);
4004  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.variable_activity_decay)
4005 }
4006 
4007 // optional double max_variable_activity_value = 16 [default = 1e+100];
4008 inline bool SatParameters::_internal_has_max_variable_activity_value() const {
4009  bool value = (_has_bits_[2] & 0x00000001u) != 0;
4010  return value;
4011 }
4012 inline bool SatParameters::has_max_variable_activity_value() const {
4013  return _internal_has_max_variable_activity_value();
4014 }
4015 inline void SatParameters::clear_max_variable_activity_value() {
4016  max_variable_activity_value_ = 1e+100;
4017  _has_bits_[2] &= ~0x00000001u;
4018 }
4019 inline double SatParameters::_internal_max_variable_activity_value() const {
4020  return max_variable_activity_value_;
4021 }
4022 inline double SatParameters::max_variable_activity_value() const {
4023  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_variable_activity_value)
4024  return _internal_max_variable_activity_value();
4025 }
4026 inline void SatParameters::_internal_set_max_variable_activity_value(double value) {
4027  _has_bits_[2] |= 0x00000001u;
4028  max_variable_activity_value_ = value;
4029 }
4030 inline void SatParameters::set_max_variable_activity_value(double value) {
4031  _internal_set_max_variable_activity_value(value);
4032  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_variable_activity_value)
4033 }
4034 
4035 // optional double glucose_max_decay = 22 [default = 0.95];
4036 inline bool SatParameters::_internal_has_glucose_max_decay() const {
4037  bool value = (_has_bits_[2] & 0x00000008u) != 0;
4038  return value;
4039 }
4040 inline bool SatParameters::has_glucose_max_decay() const {
4041  return _internal_has_glucose_max_decay();
4042 }
4043 inline void SatParameters::clear_glucose_max_decay() {
4044  glucose_max_decay_ = 0.95;
4045  _has_bits_[2] &= ~0x00000008u;
4046 }
4047 inline double SatParameters::_internal_glucose_max_decay() const {
4048  return glucose_max_decay_;
4049 }
4050 inline double SatParameters::glucose_max_decay() const {
4051  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_max_decay)
4052  return _internal_glucose_max_decay();
4053 }
4054 inline void SatParameters::_internal_set_glucose_max_decay(double value) {
4055  _has_bits_[2] |= 0x00000008u;
4056  glucose_max_decay_ = value;
4057 }
4058 inline void SatParameters::set_glucose_max_decay(double value) {
4059  _internal_set_glucose_max_decay(value);
4060  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_max_decay)
4061 }
4062 
4063 // optional double glucose_decay_increment = 23 [default = 0.01];
4064 inline bool SatParameters::_internal_has_glucose_decay_increment() const {
4065  bool value = (_has_bits_[2] & 0x00000010u) != 0;
4066  return value;
4067 }
4068 inline bool SatParameters::has_glucose_decay_increment() const {
4069  return _internal_has_glucose_decay_increment();
4070 }
4071 inline void SatParameters::clear_glucose_decay_increment() {
4072  glucose_decay_increment_ = 0.01;
4073  _has_bits_[2] &= ~0x00000010u;
4074 }
4075 inline double SatParameters::_internal_glucose_decay_increment() const {
4076  return glucose_decay_increment_;
4077 }
4078 inline double SatParameters::glucose_decay_increment() const {
4079  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_decay_increment)
4080  return _internal_glucose_decay_increment();
4081 }
4082 inline void SatParameters::_internal_set_glucose_decay_increment(double value) {
4083  _has_bits_[2] |= 0x00000010u;
4084  glucose_decay_increment_ = value;
4085 }
4086 inline void SatParameters::set_glucose_decay_increment(double value) {
4087  _internal_set_glucose_decay_increment(value);
4088  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_decay_increment)
4089 }
4090 
4091 // optional int32 glucose_decay_increment_period = 24 [default = 5000];
4092 inline bool SatParameters::_internal_has_glucose_decay_increment_period() const {
4093  bool value = (_has_bits_[2] & 0x00000020u) != 0;
4094  return value;
4095 }
4096 inline bool SatParameters::has_glucose_decay_increment_period() const {
4097  return _internal_has_glucose_decay_increment_period();
4098 }
4099 inline void SatParameters::clear_glucose_decay_increment_period() {
4100  glucose_decay_increment_period_ = 5000;
4101  _has_bits_[2] &= ~0x00000020u;
4102 }
4103 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_glucose_decay_increment_period() const {
4104  return glucose_decay_increment_period_;
4105 }
4106 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::glucose_decay_increment_period() const {
4107  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.glucose_decay_increment_period)
4108  return _internal_glucose_decay_increment_period();
4109 }
4110 inline void SatParameters::_internal_set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
4111  _has_bits_[2] |= 0x00000020u;
4112  glucose_decay_increment_period_ = value;
4113 }
4114 inline void SatParameters::set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
4115  _internal_set_glucose_decay_increment_period(value);
4116  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.glucose_decay_increment_period)
4117 }
4118 
4119 // optional double clause_activity_decay = 17 [default = 0.999];
4120 inline bool SatParameters::_internal_has_clause_activity_decay() const {
4121  bool value = (_has_bits_[2] & 0x00000002u) != 0;
4122  return value;
4123 }
4124 inline bool SatParameters::has_clause_activity_decay() const {
4125  return _internal_has_clause_activity_decay();
4126 }
4127 inline void SatParameters::clear_clause_activity_decay() {
4128  clause_activity_decay_ = 0.999;
4129  _has_bits_[2] &= ~0x00000002u;
4130 }
4131 inline double SatParameters::_internal_clause_activity_decay() const {
4132  return clause_activity_decay_;
4133 }
4134 inline double SatParameters::clause_activity_decay() const {
4135  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.clause_activity_decay)
4136  return _internal_clause_activity_decay();
4137 }
4138 inline void SatParameters::_internal_set_clause_activity_decay(double value) {
4139  _has_bits_[2] |= 0x00000002u;
4140  clause_activity_decay_ = value;
4141 }
4142 inline void SatParameters::set_clause_activity_decay(double value) {
4143  _internal_set_clause_activity_decay(value);
4144  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.clause_activity_decay)
4145 }
4146 
4147 // optional double max_clause_activity_value = 18 [default = 1e+20];
4148 inline bool SatParameters::_internal_has_max_clause_activity_value() const {
4149  bool value = (_has_bits_[2] & 0x00000004u) != 0;
4150  return value;
4151 }
4152 inline bool SatParameters::has_max_clause_activity_value() const {
4153  return _internal_has_max_clause_activity_value();
4154 }
4155 inline void SatParameters::clear_max_clause_activity_value() {
4156  max_clause_activity_value_ = 1e+20;
4157  _has_bits_[2] &= ~0x00000004u;
4158 }
4159 inline double SatParameters::_internal_max_clause_activity_value() const {
4160  return max_clause_activity_value_;
4161 }
4162 inline double SatParameters::max_clause_activity_value() const {
4163  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_clause_activity_value)
4164  return _internal_max_clause_activity_value();
4165 }
4166 inline void SatParameters::_internal_set_max_clause_activity_value(double value) {
4167  _has_bits_[2] |= 0x00000004u;
4168  max_clause_activity_value_ = value;
4169 }
4170 inline void SatParameters::set_max_clause_activity_value(double value) {
4171  _internal_set_max_clause_activity_value(value);
4172  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_clause_activity_value)
4173 }
4174 
4175 // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
4176 inline int SatParameters::_internal_restart_algorithms_size() const {
4177  return restart_algorithms_.size();
4178 }
4179 inline int SatParameters::restart_algorithms_size() const {
4180  return _internal_restart_algorithms_size();
4181 }
4182 inline void SatParameters::clear_restart_algorithms() {
4183  restart_algorithms_.Clear();
4184 }
4185 inline ::operations_research::sat::SatParameters_RestartAlgorithm SatParameters::_internal_restart_algorithms(int index) const {
4186  return static_cast< ::operations_research::sat::SatParameters_RestartAlgorithm >(restart_algorithms_.Get(index));
4187 }
4188 inline ::operations_research::sat::SatParameters_RestartAlgorithm SatParameters::restart_algorithms(int index) const {
4189  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_algorithms)
4190  return _internal_restart_algorithms(index);
4191 }
4192 inline void SatParameters::set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value) {
4193  assert(::operations_research::sat::SatParameters_RestartAlgorithm_IsValid(value));
4194  restart_algorithms_.Set(index, value);
4195  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_algorithms)
4196 }
4197 inline void SatParameters::_internal_add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value) {
4198  assert(::operations_research::sat::SatParameters_RestartAlgorithm_IsValid(value));
4199  restart_algorithms_.Add(value);
4200 }
4201 inline void SatParameters::add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value) {
4202  // @@protoc_insertion_point(field_add:operations_research.sat.SatParameters.restart_algorithms)
4203  _internal_add_restart_algorithms(value);
4204 }
4205 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
4206 SatParameters::restart_algorithms() const {
4207  // @@protoc_insertion_point(field_list:operations_research.sat.SatParameters.restart_algorithms)
4208  return restart_algorithms_;
4209 }
4210 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
4211 SatParameters::_internal_mutable_restart_algorithms() {
4212  return &restart_algorithms_;
4213 }
4214 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
4215 SatParameters::mutable_restart_algorithms() {
4216  // @@protoc_insertion_point(field_mutable_list:operations_research.sat.SatParameters.restart_algorithms)
4217  return _internal_mutable_restart_algorithms();
4218 }
4219 
4220 // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
4221 inline bool SatParameters::_internal_has_default_restart_algorithms() const {
4222  bool value = (_has_bits_[0] & 0x00000001u) != 0;
4223  return value;
4224 }
4225 inline bool SatParameters::has_default_restart_algorithms() const {
4226  return _internal_has_default_restart_algorithms();
4227 }
4228 inline void SatParameters::clear_default_restart_algorithms() {
4229  default_restart_algorithms_.ClearToDefault(::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_, GetArena());
4230  _has_bits_[0] &= ~0x00000001u;
4231 }
4232 inline const std::string& SatParameters::default_restart_algorithms() const {
4233  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.default_restart_algorithms)
4234  if (default_restart_algorithms_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_default_restart_algorithms_.get();
4235  return _internal_default_restart_algorithms();
4236 }
4237 inline void SatParameters::set_default_restart_algorithms(const std::string& value) {
4238  _internal_set_default_restart_algorithms(value);
4239  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.default_restart_algorithms)
4240 }
4241 inline std::string* SatParameters::mutable_default_restart_algorithms() {
4242  // @@protoc_insertion_point(field_mutable:operations_research.sat.SatParameters.default_restart_algorithms)
4243  return _internal_mutable_default_restart_algorithms();
4244 }
4245 inline const std::string& SatParameters::_internal_default_restart_algorithms() const {
4246  return default_restart_algorithms_.Get();
4247 }
4248 inline void SatParameters::_internal_set_default_restart_algorithms(const std::string& value) {
4249  _has_bits_[0] |= 0x00000001u;
4250  default_restart_algorithms_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArena());
4251 }
4252 inline void SatParameters::set_default_restart_algorithms(std::string&& value) {
4253  _has_bits_[0] |= 0x00000001u;
4254  default_restart_algorithms_.Set(
4255  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, ::std::move(value), GetArena());
4256  // @@protoc_insertion_point(field_set_rvalue:operations_research.sat.SatParameters.default_restart_algorithms)
4257 }
4258 inline void SatParameters::set_default_restart_algorithms(const char* value) {
4259  GOOGLE_DCHECK(value != nullptr);
4260  _has_bits_[0] |= 0x00000001u;
4261  default_restart_algorithms_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, ::std::string(value), GetArena());
4262  // @@protoc_insertion_point(field_set_char:operations_research.sat.SatParameters.default_restart_algorithms)
4263 }
4264 inline void SatParameters::set_default_restart_algorithms(const char* value,
4265  size_t size) {
4266  _has_bits_[0] |= 0x00000001u;
4267  default_restart_algorithms_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, ::std::string(
4268  reinterpret_cast<const char*>(value), size), GetArena());
4269  // @@protoc_insertion_point(field_set_pointer:operations_research.sat.SatParameters.default_restart_algorithms)
4270 }
4271 inline std::string* SatParameters::_internal_mutable_default_restart_algorithms() {
4272  _has_bits_[0] |= 0x00000001u;
4273  return default_restart_algorithms_.Mutable(::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_, GetArena());
4274 }
4275 inline std::string* SatParameters::release_default_restart_algorithms() {
4276  // @@protoc_insertion_point(field_release:operations_research.sat.SatParameters.default_restart_algorithms)
4277  if (!_internal_has_default_restart_algorithms()) {
4278  return nullptr;
4279  }
4280  _has_bits_[0] &= ~0x00000001u;
4281  return default_restart_algorithms_.ReleaseNonDefault(nullptr, GetArena());
4282 }
4283 inline void SatParameters::set_allocated_default_restart_algorithms(std::string* default_restart_algorithms) {
4284  if (default_restart_algorithms != nullptr) {
4285  _has_bits_[0] |= 0x00000001u;
4286  } else {
4287  _has_bits_[0] &= ~0x00000001u;
4288  }
4289  default_restart_algorithms_.SetAllocated(nullptr, default_restart_algorithms,
4290  GetArena());
4291  // @@protoc_insertion_point(field_set_allocated:operations_research.sat.SatParameters.default_restart_algorithms)
4292 }
4293 
4294 // optional int32 restart_period = 30 [default = 50];
4295 inline bool SatParameters::_internal_has_restart_period() const {
4296  bool value = (_has_bits_[2] & 0x00000040u) != 0;
4297  return value;
4298 }
4299 inline bool SatParameters::has_restart_period() const {
4300  return _internal_has_restart_period();
4301 }
4302 inline void SatParameters::clear_restart_period() {
4303  restart_period_ = 50;
4304  _has_bits_[2] &= ~0x00000040u;
4305 }
4306 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_restart_period() const {
4307  return restart_period_;
4308 }
4309 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::restart_period() const {
4310  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_period)
4311  return _internal_restart_period();
4312 }
4313 inline void SatParameters::_internal_set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
4314  _has_bits_[2] |= 0x00000040u;
4315  restart_period_ = value;
4316 }
4317 inline void SatParameters::set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value) {
4318  _internal_set_restart_period(value);
4319  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_period)
4320 }
4321 
4322 // optional int32 restart_running_window_size = 62 [default = 50];
4323 inline bool SatParameters::_internal_has_restart_running_window_size() const {
4324  bool value = (_has_bits_[2] & 0x01000000u) != 0;
4325  return value;
4326 }
4327 inline bool SatParameters::has_restart_running_window_size() const {
4328  return _internal_has_restart_running_window_size();
4329 }
4330 inline void SatParameters::clear_restart_running_window_size() {
4331  restart_running_window_size_ = 50;
4332  _has_bits_[2] &= ~0x01000000u;
4333 }
4334 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_restart_running_window_size() const {
4335  return restart_running_window_size_;
4336 }
4337 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::restart_running_window_size() const {
4338  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_running_window_size)
4339  return _internal_restart_running_window_size();
4340 }
4341 inline void SatParameters::_internal_set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
4342  _has_bits_[2] |= 0x01000000u;
4343  restart_running_window_size_ = value;
4344 }
4345 inline void SatParameters::set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
4346  _internal_set_restart_running_window_size(value);
4347  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_running_window_size)
4348 }
4349 
4350 // optional double restart_dl_average_ratio = 63 [default = 1];
4351 inline bool SatParameters::_internal_has_restart_dl_average_ratio() const {
4352  bool value = (_has_bits_[2] & 0x00800000u) != 0;
4353  return value;
4354 }
4355 inline bool SatParameters::has_restart_dl_average_ratio() const {
4356  return _internal_has_restart_dl_average_ratio();
4357 }
4358 inline void SatParameters::clear_restart_dl_average_ratio() {
4359  restart_dl_average_ratio_ = 1;
4360  _has_bits_[2] &= ~0x00800000u;
4361 }
4362 inline double SatParameters::_internal_restart_dl_average_ratio() const {
4363  return restart_dl_average_ratio_;
4364 }
4365 inline double SatParameters::restart_dl_average_ratio() const {
4366  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_dl_average_ratio)
4367  return _internal_restart_dl_average_ratio();
4368 }
4369 inline void SatParameters::_internal_set_restart_dl_average_ratio(double value) {
4370  _has_bits_[2] |= 0x00800000u;
4371  restart_dl_average_ratio_ = value;
4372 }
4373 inline void SatParameters::set_restart_dl_average_ratio(double value) {
4374  _internal_set_restart_dl_average_ratio(value);
4375  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_dl_average_ratio)
4376 }
4377 
4378 // optional double restart_lbd_average_ratio = 71 [default = 1];
4379 inline bool SatParameters::_internal_has_restart_lbd_average_ratio() const {
4380  bool value = (_has_bits_[3] & 0x00000002u) != 0;
4381  return value;
4382 }
4383 inline bool SatParameters::has_restart_lbd_average_ratio() const {
4384  return _internal_has_restart_lbd_average_ratio();
4385 }
4386 inline void SatParameters::clear_restart_lbd_average_ratio() {
4387  restart_lbd_average_ratio_ = 1;
4388  _has_bits_[3] &= ~0x00000002u;
4389 }
4390 inline double SatParameters::_internal_restart_lbd_average_ratio() const {
4391  return restart_lbd_average_ratio_;
4392 }
4393 inline double SatParameters::restart_lbd_average_ratio() const {
4394  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.restart_lbd_average_ratio)
4395  return _internal_restart_lbd_average_ratio();
4396 }
4397 inline void SatParameters::_internal_set_restart_lbd_average_ratio(double value) {
4398  _has_bits_[3] |= 0x00000002u;
4399  restart_lbd_average_ratio_ = value;
4400 }
4401 inline void SatParameters::set_restart_lbd_average_ratio(double value) {
4402  _internal_set_restart_lbd_average_ratio(value);
4403  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.restart_lbd_average_ratio)
4404 }
4405 
4406 // optional bool use_blocking_restart = 64 [default = false];
4407 inline bool SatParameters::_internal_has_use_blocking_restart() const {
4408  bool value = (_has_bits_[0] & 0x00040000u) != 0;
4409  return value;
4410 }
4411 inline bool SatParameters::has_use_blocking_restart() const {
4412  return _internal_has_use_blocking_restart();
4413 }
4414 inline void SatParameters::clear_use_blocking_restart() {
4415  use_blocking_restart_ = false;
4416  _has_bits_[0] &= ~0x00040000u;
4417 }
4418 inline bool SatParameters::_internal_use_blocking_restart() const {
4419  return use_blocking_restart_;
4420 }
4421 inline bool SatParameters::use_blocking_restart() const {
4422  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_blocking_restart)
4423  return _internal_use_blocking_restart();
4424 }
4425 inline void SatParameters::_internal_set_use_blocking_restart(bool value) {
4426  _has_bits_[0] |= 0x00040000u;
4427  use_blocking_restart_ = value;
4428 }
4429 inline void SatParameters::set_use_blocking_restart(bool value) {
4430  _internal_set_use_blocking_restart(value);
4431  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_blocking_restart)
4432 }
4433 
4434 // optional int32 blocking_restart_window_size = 65 [default = 5000];
4435 inline bool SatParameters::_internal_has_blocking_restart_window_size() const {
4436  bool value = (_has_bits_[2] & 0x80000000u) != 0;
4437  return value;
4438 }
4439 inline bool SatParameters::has_blocking_restart_window_size() const {
4440  return _internal_has_blocking_restart_window_size();
4441 }
4442 inline void SatParameters::clear_blocking_restart_window_size() {
4443  blocking_restart_window_size_ = 5000;
4444  _has_bits_[2] &= ~0x80000000u;
4445 }
4446 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_blocking_restart_window_size() const {
4447  return blocking_restart_window_size_;
4448 }
4449 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::blocking_restart_window_size() const {
4450  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.blocking_restart_window_size)
4451  return _internal_blocking_restart_window_size();
4452 }
4453 inline void SatParameters::_internal_set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
4454  _has_bits_[2] |= 0x80000000u;
4455  blocking_restart_window_size_ = value;
4456 }
4457 inline void SatParameters::set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
4458  _internal_set_blocking_restart_window_size(value);
4459  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.blocking_restart_window_size)
4460 }
4461 
4462 // optional double blocking_restart_multiplier = 66 [default = 1.4];
4463 inline bool SatParameters::_internal_has_blocking_restart_multiplier() const {
4464  bool value = (_has_bits_[2] & 0x20000000u) != 0;
4465  return value;
4466 }
4467 inline bool SatParameters::has_blocking_restart_multiplier() const {
4468  return _internal_has_blocking_restart_multiplier();
4469 }
4470 inline void SatParameters::clear_blocking_restart_multiplier() {
4471  blocking_restart_multiplier_ = 1.4;
4472  _has_bits_[2] &= ~0x20000000u;
4473 }
4474 inline double SatParameters::_internal_blocking_restart_multiplier() const {
4475  return blocking_restart_multiplier_;
4476 }
4477 inline double SatParameters::blocking_restart_multiplier() const {
4478  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.blocking_restart_multiplier)
4479  return _internal_blocking_restart_multiplier();
4480 }
4481 inline void SatParameters::_internal_set_blocking_restart_multiplier(double value) {
4482  _has_bits_[2] |= 0x20000000u;
4483  blocking_restart_multiplier_ = value;
4484 }
4485 inline void SatParameters::set_blocking_restart_multiplier(double value) {
4486  _internal_set_blocking_restart_multiplier(value);
4487  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.blocking_restart_multiplier)
4488 }
4489 
4490 // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
4491 inline bool SatParameters::_internal_has_num_conflicts_before_strategy_changes() const {
4492  bool value = (_has_bits_[0] & 0x00000200u) != 0;
4493  return value;
4494 }
4495 inline bool SatParameters::has_num_conflicts_before_strategy_changes() const {
4496  return _internal_has_num_conflicts_before_strategy_changes();
4497 }
4498 inline void SatParameters::clear_num_conflicts_before_strategy_changes() {
4499  num_conflicts_before_strategy_changes_ = 0;
4500  _has_bits_[0] &= ~0x00000200u;
4501 }
4502 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_num_conflicts_before_strategy_changes() const {
4503  return num_conflicts_before_strategy_changes_;
4504 }
4505 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::num_conflicts_before_strategy_changes() const {
4506  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_conflicts_before_strategy_changes)
4507  return _internal_num_conflicts_before_strategy_changes();
4508 }
4509 inline void SatParameters::_internal_set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value) {
4510  _has_bits_[0] |= 0x00000200u;
4511  num_conflicts_before_strategy_changes_ = value;
4512 }
4513 inline void SatParameters::set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value) {
4514  _internal_set_num_conflicts_before_strategy_changes(value);
4515  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_conflicts_before_strategy_changes)
4516 }
4517 
4518 // optional double strategy_change_increase_ratio = 69 [default = 0];
4519 inline bool SatParameters::_internal_has_strategy_change_increase_ratio() const {
4520  bool value = (_has_bits_[0] & 0x00000100u) != 0;
4521  return value;
4522 }
4523 inline bool SatParameters::has_strategy_change_increase_ratio() const {
4524  return _internal_has_strategy_change_increase_ratio();
4525 }
4526 inline void SatParameters::clear_strategy_change_increase_ratio() {
4527  strategy_change_increase_ratio_ = 0;
4528  _has_bits_[0] &= ~0x00000100u;
4529 }
4530 inline double SatParameters::_internal_strategy_change_increase_ratio() const {
4531  return strategy_change_increase_ratio_;
4532 }
4533 inline double SatParameters::strategy_change_increase_ratio() const {
4534  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.strategy_change_increase_ratio)
4535  return _internal_strategy_change_increase_ratio();
4536 }
4537 inline void SatParameters::_internal_set_strategy_change_increase_ratio(double value) {
4538  _has_bits_[0] |= 0x00000100u;
4539  strategy_change_increase_ratio_ = value;
4540 }
4541 inline void SatParameters::set_strategy_change_increase_ratio(double value) {
4542  _internal_set_strategy_change_increase_ratio(value);
4543  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.strategy_change_increase_ratio)
4544 }
4545 
4546 // optional double max_time_in_seconds = 36 [default = inf];
4547 inline bool SatParameters::_internal_has_max_time_in_seconds() const {
4548  bool value = (_has_bits_[2] & 0x00000200u) != 0;
4549  return value;
4550 }
4551 inline bool SatParameters::has_max_time_in_seconds() const {
4552  return _internal_has_max_time_in_seconds();
4553 }
4554 inline void SatParameters::clear_max_time_in_seconds() {
4555  max_time_in_seconds_ = std::numeric_limits<double>::infinity();
4556  _has_bits_[2] &= ~0x00000200u;
4557 }
4558 inline double SatParameters::_internal_max_time_in_seconds() const {
4559  return max_time_in_seconds_;
4560 }
4561 inline double SatParameters::max_time_in_seconds() const {
4562  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_time_in_seconds)
4563  return _internal_max_time_in_seconds();
4564 }
4565 inline void SatParameters::_internal_set_max_time_in_seconds(double value) {
4566  _has_bits_[2] |= 0x00000200u;
4567  max_time_in_seconds_ = value;
4568 }
4569 inline void SatParameters::set_max_time_in_seconds(double value) {
4570  _internal_set_max_time_in_seconds(value);
4571  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_time_in_seconds)
4572 }
4573 
4574 // optional double max_deterministic_time = 67 [default = inf];
4575 inline bool SatParameters::_internal_has_max_deterministic_time() const {
4576  bool value = (_has_bits_[2] & 0x40000000u) != 0;
4577  return value;
4578 }
4579 inline bool SatParameters::has_max_deterministic_time() const {
4580  return _internal_has_max_deterministic_time();
4581 }
4582 inline void SatParameters::clear_max_deterministic_time() {
4583  max_deterministic_time_ = std::numeric_limits<double>::infinity();
4584  _has_bits_[2] &= ~0x40000000u;
4585 }
4586 inline double SatParameters::_internal_max_deterministic_time() const {
4587  return max_deterministic_time_;
4588 }
4589 inline double SatParameters::max_deterministic_time() const {
4590  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_deterministic_time)
4591  return _internal_max_deterministic_time();
4592 }
4593 inline void SatParameters::_internal_set_max_deterministic_time(double value) {
4594  _has_bits_[2] |= 0x40000000u;
4595  max_deterministic_time_ = value;
4596 }
4597 inline void SatParameters::set_max_deterministic_time(double value) {
4598  _internal_set_max_deterministic_time(value);
4599  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_deterministic_time)
4600 }
4601 
4602 // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
4603 inline bool SatParameters::_internal_has_max_number_of_conflicts() const {
4604  bool value = (_has_bits_[2] & 0x00000400u) != 0;
4605  return value;
4606 }
4607 inline bool SatParameters::has_max_number_of_conflicts() const {
4608  return _internal_has_max_number_of_conflicts();
4609 }
4610 inline void SatParameters::clear_max_number_of_conflicts() {
4611  max_number_of_conflicts_ = PROTOBUF_LONGLONG(9223372036854775807);
4612  _has_bits_[2] &= ~0x00000400u;
4613 }
4614 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_max_number_of_conflicts() const {
4615  return max_number_of_conflicts_;
4616 }
4617 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::max_number_of_conflicts() const {
4618  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_number_of_conflicts)
4619  return _internal_max_number_of_conflicts();
4620 }
4621 inline void SatParameters::_internal_set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value) {
4622  _has_bits_[2] |= 0x00000400u;
4623  max_number_of_conflicts_ = value;
4624 }
4625 inline void SatParameters::set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value) {
4626  _internal_set_max_number_of_conflicts(value);
4627  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_number_of_conflicts)
4628 }
4629 
4630 // optional int64 max_memory_in_mb = 40 [default = 10000];
4631 inline bool SatParameters::_internal_has_max_memory_in_mb() const {
4632  bool value = (_has_bits_[2] & 0x00000800u) != 0;
4633  return value;
4634 }
4635 inline bool SatParameters::has_max_memory_in_mb() const {
4636  return _internal_has_max_memory_in_mb();
4637 }
4638 inline void SatParameters::clear_max_memory_in_mb() {
4639  max_memory_in_mb_ = PROTOBUF_LONGLONG(10000);
4640  _has_bits_[2] &= ~0x00000800u;
4641 }
4642 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_max_memory_in_mb() const {
4643  return max_memory_in_mb_;
4644 }
4645 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::max_memory_in_mb() const {
4646  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_memory_in_mb)
4647  return _internal_max_memory_in_mb();
4648 }
4649 inline void SatParameters::_internal_set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value) {
4650  _has_bits_[2] |= 0x00000800u;
4651  max_memory_in_mb_ = value;
4652 }
4653 inline void SatParameters::set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value) {
4654  _internal_set_max_memory_in_mb(value);
4655  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_memory_in_mb)
4656 }
4657 
4658 // optional double absolute_gap_limit = 159 [default = 0];
4659 inline bool SatParameters::_internal_has_absolute_gap_limit() const {
4660  bool value = (_has_bits_[1] & 0x00080000u) != 0;
4661  return value;
4662 }
4663 inline bool SatParameters::has_absolute_gap_limit() const {
4664  return _internal_has_absolute_gap_limit();
4665 }
4666 inline void SatParameters::clear_absolute_gap_limit() {
4667  absolute_gap_limit_ = 0;
4668  _has_bits_[1] &= ~0x00080000u;
4669 }
4670 inline double SatParameters::_internal_absolute_gap_limit() const {
4671  return absolute_gap_limit_;
4672 }
4673 inline double SatParameters::absolute_gap_limit() const {
4674  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.absolute_gap_limit)
4675  return _internal_absolute_gap_limit();
4676 }
4677 inline void SatParameters::_internal_set_absolute_gap_limit(double value) {
4678  _has_bits_[1] |= 0x00080000u;
4679  absolute_gap_limit_ = value;
4680 }
4681 inline void SatParameters::set_absolute_gap_limit(double value) {
4682  _internal_set_absolute_gap_limit(value);
4683  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.absolute_gap_limit)
4684 }
4685 
4686 // optional double relative_gap_limit = 160 [default = 0];
4687 inline bool SatParameters::_internal_has_relative_gap_limit() const {
4688  bool value = (_has_bits_[1] & 0x00100000u) != 0;
4689  return value;
4690 }
4691 inline bool SatParameters::has_relative_gap_limit() const {
4692  return _internal_has_relative_gap_limit();
4693 }
4694 inline void SatParameters::clear_relative_gap_limit() {
4695  relative_gap_limit_ = 0;
4696  _has_bits_[1] &= ~0x00100000u;
4697 }
4698 inline double SatParameters::_internal_relative_gap_limit() const {
4699  return relative_gap_limit_;
4700 }
4701 inline double SatParameters::relative_gap_limit() const {
4702  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.relative_gap_limit)
4703  return _internal_relative_gap_limit();
4704 }
4705 inline void SatParameters::_internal_set_relative_gap_limit(double value) {
4706  _has_bits_[1] |= 0x00100000u;
4707  relative_gap_limit_ = value;
4708 }
4709 inline void SatParameters::set_relative_gap_limit(double value) {
4710  _internal_set_relative_gap_limit(value);
4711  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.relative_gap_limit)
4712 }
4713 
4714 // optional bool treat_binary_clauses_separately = 33 [default = true];
4715 inline bool SatParameters::_internal_has_treat_binary_clauses_separately() const {
4716  bool value = (_has_bits_[2] & 0x00004000u) != 0;
4717  return value;
4718 }
4719 inline bool SatParameters::has_treat_binary_clauses_separately() const {
4720  return _internal_has_treat_binary_clauses_separately();
4721 }
4722 inline void SatParameters::clear_treat_binary_clauses_separately() {
4723  treat_binary_clauses_separately_ = true;
4724  _has_bits_[2] &= ~0x00004000u;
4725 }
4726 inline bool SatParameters::_internal_treat_binary_clauses_separately() const {
4727  return treat_binary_clauses_separately_;
4728 }
4729 inline bool SatParameters::treat_binary_clauses_separately() const {
4730  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.treat_binary_clauses_separately)
4731  return _internal_treat_binary_clauses_separately();
4732 }
4733 inline void SatParameters::_internal_set_treat_binary_clauses_separately(bool value) {
4734  _has_bits_[2] |= 0x00004000u;
4735  treat_binary_clauses_separately_ = value;
4736 }
4737 inline void SatParameters::set_treat_binary_clauses_separately(bool value) {
4738  _internal_set_treat_binary_clauses_separately(value);
4739  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.treat_binary_clauses_separately)
4740 }
4741 
4742 // optional int32 random_seed = 31 [default = 1];
4743 inline bool SatParameters::_internal_has_random_seed() const {
4744  bool value = (_has_bits_[2] & 0x00000080u) != 0;
4745  return value;
4746 }
4747 inline bool SatParameters::has_random_seed() const {
4748  return _internal_has_random_seed();
4749 }
4750 inline void SatParameters::clear_random_seed() {
4751  random_seed_ = 1;
4752  _has_bits_[2] &= ~0x00000080u;
4753 }
4754 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_random_seed() const {
4755  return random_seed_;
4756 }
4757 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::random_seed() const {
4758  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.random_seed)
4759  return _internal_random_seed();
4760 }
4761 inline void SatParameters::_internal_set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value) {
4762  _has_bits_[2] |= 0x00000080u;
4763  random_seed_ = value;
4764 }
4765 inline void SatParameters::set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value) {
4766  _internal_set_random_seed(value);
4767  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.random_seed)
4768 }
4769 
4770 // optional bool permute_variable_randomly = 178 [default = false];
4771 inline bool SatParameters::_internal_has_permute_variable_randomly() const {
4772  bool value = (_has_bits_[0] & 0x00080000u) != 0;
4773  return value;
4774 }
4775 inline bool SatParameters::has_permute_variable_randomly() const {
4776  return _internal_has_permute_variable_randomly();
4777 }
4778 inline void SatParameters::clear_permute_variable_randomly() {
4779  permute_variable_randomly_ = false;
4780  _has_bits_[0] &= ~0x00080000u;
4781 }
4782 inline bool SatParameters::_internal_permute_variable_randomly() const {
4783  return permute_variable_randomly_;
4784 }
4785 inline bool SatParameters::permute_variable_randomly() const {
4786  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.permute_variable_randomly)
4787  return _internal_permute_variable_randomly();
4788 }
4789 inline void SatParameters::_internal_set_permute_variable_randomly(bool value) {
4790  _has_bits_[0] |= 0x00080000u;
4791  permute_variable_randomly_ = value;
4792 }
4793 inline void SatParameters::set_permute_variable_randomly(bool value) {
4794  _internal_set_permute_variable_randomly(value);
4795  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.permute_variable_randomly)
4796 }
4797 
4798 // optional bool permute_presolve_constraint_order = 179 [default = false];
4799 inline bool SatParameters::_internal_has_permute_presolve_constraint_order() const {
4800  bool value = (_has_bits_[1] & 0x00004000u) != 0;
4801  return value;
4802 }
4803 inline bool SatParameters::has_permute_presolve_constraint_order() const {
4804  return _internal_has_permute_presolve_constraint_order();
4805 }
4806 inline void SatParameters::clear_permute_presolve_constraint_order() {
4807  permute_presolve_constraint_order_ = false;
4808  _has_bits_[1] &= ~0x00004000u;
4809 }
4810 inline bool SatParameters::_internal_permute_presolve_constraint_order() const {
4811  return permute_presolve_constraint_order_;
4812 }
4813 inline bool SatParameters::permute_presolve_constraint_order() const {
4814  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.permute_presolve_constraint_order)
4815  return _internal_permute_presolve_constraint_order();
4816 }
4817 inline void SatParameters::_internal_set_permute_presolve_constraint_order(bool value) {
4818  _has_bits_[1] |= 0x00004000u;
4819  permute_presolve_constraint_order_ = value;
4820 }
4821 inline void SatParameters::set_permute_presolve_constraint_order(bool value) {
4822  _internal_set_permute_presolve_constraint_order(value);
4823  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.permute_presolve_constraint_order)
4824 }
4825 
4826 // optional bool use_absl_random = 180 [default = false];
4827 inline bool SatParameters::_internal_has_use_absl_random() const {
4828  bool value = (_has_bits_[1] & 0x00008000u) != 0;
4829  return value;
4830 }
4831 inline bool SatParameters::has_use_absl_random() const {
4832  return _internal_has_use_absl_random();
4833 }
4834 inline void SatParameters::clear_use_absl_random() {
4835  use_absl_random_ = false;
4836  _has_bits_[1] &= ~0x00008000u;
4837 }
4838 inline bool SatParameters::_internal_use_absl_random() const {
4839  return use_absl_random_;
4840 }
4841 inline bool SatParameters::use_absl_random() const {
4842  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_absl_random)
4843  return _internal_use_absl_random();
4844 }
4845 inline void SatParameters::_internal_set_use_absl_random(bool value) {
4846  _has_bits_[1] |= 0x00008000u;
4847  use_absl_random_ = value;
4848 }
4849 inline void SatParameters::set_use_absl_random(bool value) {
4850  _internal_set_use_absl_random(value);
4851  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_absl_random)
4852 }
4853 
4854 // optional bool log_search_progress = 41 [default = false];
4855 inline bool SatParameters::_internal_has_log_search_progress() const {
4856  bool value = (_has_bits_[1] & 0x00010000u) != 0;
4857  return value;
4858 }
4859 inline bool SatParameters::has_log_search_progress() const {
4860  return _internal_has_log_search_progress();
4861 }
4862 inline void SatParameters::clear_log_search_progress() {
4863  log_search_progress_ = false;
4864  _has_bits_[1] &= ~0x00010000u;
4865 }
4866 inline bool SatParameters::_internal_log_search_progress() const {
4867  return log_search_progress_;
4868 }
4869 inline bool SatParameters::log_search_progress() const {
4870  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.log_search_progress)
4871  return _internal_log_search_progress();
4872 }
4873 inline void SatParameters::_internal_set_log_search_progress(bool value) {
4874  _has_bits_[1] |= 0x00010000u;
4875  log_search_progress_ = value;
4876 }
4877 inline void SatParameters::set_log_search_progress(bool value) {
4878  _internal_set_log_search_progress(value);
4879  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.log_search_progress)
4880 }
4881 
4882 // optional bool fill_logs_in_response = 185 [default = false];
4883 inline bool SatParameters::_internal_has_fill_logs_in_response() const {
4884  bool value = (_has_bits_[1] & 0x00020000u) != 0;
4885  return value;
4886 }
4887 inline bool SatParameters::has_fill_logs_in_response() const {
4888  return _internal_has_fill_logs_in_response();
4889 }
4890 inline void SatParameters::clear_fill_logs_in_response() {
4891  fill_logs_in_response_ = false;
4892  _has_bits_[1] &= ~0x00020000u;
4893 }
4894 inline bool SatParameters::_internal_fill_logs_in_response() const {
4895  return fill_logs_in_response_;
4896 }
4897 inline bool SatParameters::fill_logs_in_response() const {
4898  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fill_logs_in_response)
4899  return _internal_fill_logs_in_response();
4900 }
4901 inline void SatParameters::_internal_set_fill_logs_in_response(bool value) {
4902  _has_bits_[1] |= 0x00020000u;
4903  fill_logs_in_response_ = value;
4904 }
4905 inline void SatParameters::set_fill_logs_in_response(bool value) {
4906  _internal_set_fill_logs_in_response(value);
4907  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fill_logs_in_response)
4908 }
4909 
4910 // optional bool use_pb_resolution = 43 [default = false];
4911 inline bool SatParameters::_internal_has_use_pb_resolution() const {
4912  bool value = (_has_bits_[0] & 0x00200000u) != 0;
4913  return value;
4914 }
4915 inline bool SatParameters::has_use_pb_resolution() const {
4916  return _internal_has_use_pb_resolution();
4917 }
4918 inline void SatParameters::clear_use_pb_resolution() {
4919  use_pb_resolution_ = false;
4920  _has_bits_[0] &= ~0x00200000u;
4921 }
4922 inline bool SatParameters::_internal_use_pb_resolution() const {
4923  return use_pb_resolution_;
4924 }
4925 inline bool SatParameters::use_pb_resolution() const {
4926  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_pb_resolution)
4927  return _internal_use_pb_resolution();
4928 }
4929 inline void SatParameters::_internal_set_use_pb_resolution(bool value) {
4930  _has_bits_[0] |= 0x00200000u;
4931  use_pb_resolution_ = value;
4932 }
4933 inline void SatParameters::set_use_pb_resolution(bool value) {
4934  _internal_set_use_pb_resolution(value);
4935  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_pb_resolution)
4936 }
4937 
4938 // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
4939 inline bool SatParameters::_internal_has_minimize_reduction_during_pb_resolution() const {
4940  bool value = (_has_bits_[0] & 0x00400000u) != 0;
4941  return value;
4942 }
4943 inline bool SatParameters::has_minimize_reduction_during_pb_resolution() const {
4944  return _internal_has_minimize_reduction_during_pb_resolution();
4945 }
4946 inline void SatParameters::clear_minimize_reduction_during_pb_resolution() {
4947  minimize_reduction_during_pb_resolution_ = false;
4948  _has_bits_[0] &= ~0x00400000u;
4949 }
4950 inline bool SatParameters::_internal_minimize_reduction_during_pb_resolution() const {
4951  return minimize_reduction_during_pb_resolution_;
4952 }
4953 inline bool SatParameters::minimize_reduction_during_pb_resolution() const {
4954  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_reduction_during_pb_resolution)
4955  return _internal_minimize_reduction_during_pb_resolution();
4956 }
4957 inline void SatParameters::_internal_set_minimize_reduction_during_pb_resolution(bool value) {
4958  _has_bits_[0] |= 0x00400000u;
4959  minimize_reduction_during_pb_resolution_ = value;
4960 }
4961 inline void SatParameters::set_minimize_reduction_during_pb_resolution(bool value) {
4962  _internal_set_minimize_reduction_during_pb_resolution(value);
4963  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_reduction_during_pb_resolution)
4964 }
4965 
4966 // optional bool count_assumption_levels_in_lbd = 49 [default = true];
4967 inline bool SatParameters::_internal_has_count_assumption_levels_in_lbd() const {
4968  bool value = (_has_bits_[2] & 0x00008000u) != 0;
4969  return value;
4970 }
4971 inline bool SatParameters::has_count_assumption_levels_in_lbd() const {
4972  return _internal_has_count_assumption_levels_in_lbd();
4973 }
4974 inline void SatParameters::clear_count_assumption_levels_in_lbd() {
4975  count_assumption_levels_in_lbd_ = true;
4976  _has_bits_[2] &= ~0x00008000u;
4977 }
4978 inline bool SatParameters::_internal_count_assumption_levels_in_lbd() const {
4979  return count_assumption_levels_in_lbd_;
4980 }
4981 inline bool SatParameters::count_assumption_levels_in_lbd() const {
4982  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.count_assumption_levels_in_lbd)
4983  return _internal_count_assumption_levels_in_lbd();
4984 }
4985 inline void SatParameters::_internal_set_count_assumption_levels_in_lbd(bool value) {
4986  _has_bits_[2] |= 0x00008000u;
4987  count_assumption_levels_in_lbd_ = value;
4988 }
4989 inline void SatParameters::set_count_assumption_levels_in_lbd(bool value) {
4990  _internal_set_count_assumption_levels_in_lbd(value);
4991  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.count_assumption_levels_in_lbd)
4992 }
4993 
4994 // optional int32 presolve_bve_threshold = 54 [default = 500];
4995 inline bool SatParameters::_internal_has_presolve_bve_threshold() const {
4996  bool value = (_has_bits_[2] & 0x00080000u) != 0;
4997  return value;
4998 }
4999 inline bool SatParameters::has_presolve_bve_threshold() const {
5000  return _internal_has_presolve_bve_threshold();
5001 }
5002 inline void SatParameters::clear_presolve_bve_threshold() {
5003  presolve_bve_threshold_ = 500;
5004  _has_bits_[2] &= ~0x00080000u;
5005 }
5006 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bve_threshold() const {
5007  return presolve_bve_threshold_;
5008 }
5009 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bve_threshold() const {
5010  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bve_threshold)
5011  return _internal_presolve_bve_threshold();
5012 }
5013 inline void SatParameters::_internal_set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
5014  _has_bits_[2] |= 0x00080000u;
5015  presolve_bve_threshold_ = value;
5016 }
5017 inline void SatParameters::set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
5018  _internal_set_presolve_bve_threshold(value);
5019  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bve_threshold)
5020 }
5021 
5022 // optional int32 presolve_bve_clause_weight = 55 [default = 3];
5023 inline bool SatParameters::_internal_has_presolve_bve_clause_weight() const {
5024  bool value = (_has_bits_[2] & 0x00200000u) != 0;
5025  return value;
5026 }
5027 inline bool SatParameters::has_presolve_bve_clause_weight() const {
5028  return _internal_has_presolve_bve_clause_weight();
5029 }
5030 inline void SatParameters::clear_presolve_bve_clause_weight() {
5031  presolve_bve_clause_weight_ = 3;
5032  _has_bits_[2] &= ~0x00200000u;
5033 }
5034 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bve_clause_weight() const {
5035  return presolve_bve_clause_weight_;
5036 }
5037 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bve_clause_weight() const {
5038  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bve_clause_weight)
5039  return _internal_presolve_bve_clause_weight();
5040 }
5041 inline void SatParameters::_internal_set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
5042  _has_bits_[2] |= 0x00200000u;
5043  presolve_bve_clause_weight_ = value;
5044 }
5045 inline void SatParameters::set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value) {
5046  _internal_set_presolve_bve_clause_weight(value);
5047  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bve_clause_weight)
5048 }
5049 
5050 // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
5051 inline bool SatParameters::_internal_has_presolve_probing_deterministic_time_limit() const {
5052  bool value = (_has_bits_[2] & 0x00100000u) != 0;
5053  return value;
5054 }
5055 inline bool SatParameters::has_presolve_probing_deterministic_time_limit() const {
5056  return _internal_has_presolve_probing_deterministic_time_limit();
5057 }
5058 inline void SatParameters::clear_presolve_probing_deterministic_time_limit() {
5059  presolve_probing_deterministic_time_limit_ = 30;
5060  _has_bits_[2] &= ~0x00100000u;
5061 }
5062 inline double SatParameters::_internal_presolve_probing_deterministic_time_limit() const {
5063  return presolve_probing_deterministic_time_limit_;
5064 }
5065 inline double SatParameters::presolve_probing_deterministic_time_limit() const {
5066  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_probing_deterministic_time_limit)
5067  return _internal_presolve_probing_deterministic_time_limit();
5068 }
5069 inline void SatParameters::_internal_set_presolve_probing_deterministic_time_limit(double value) {
5070  _has_bits_[2] |= 0x00100000u;
5071  presolve_probing_deterministic_time_limit_ = value;
5072 }
5073 inline void SatParameters::set_presolve_probing_deterministic_time_limit(double value) {
5074  _internal_set_presolve_probing_deterministic_time_limit(value);
5075  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_probing_deterministic_time_limit)
5076 }
5077 
5078 // optional bool presolve_blocked_clause = 88 [default = true];
5079 inline bool SatParameters::_internal_has_presolve_blocked_clause() const {
5080  bool value = (_has_bits_[3] & 0x00000004u) != 0;
5081  return value;
5082 }
5083 inline bool SatParameters::has_presolve_blocked_clause() const {
5084  return _internal_has_presolve_blocked_clause();
5085 }
5086 inline void SatParameters::clear_presolve_blocked_clause() {
5087  presolve_blocked_clause_ = true;
5088  _has_bits_[3] &= ~0x00000004u;
5089 }
5090 inline bool SatParameters::_internal_presolve_blocked_clause() const {
5091  return presolve_blocked_clause_;
5092 }
5093 inline bool SatParameters::presolve_blocked_clause() const {
5094  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_blocked_clause)
5095  return _internal_presolve_blocked_clause();
5096 }
5097 inline void SatParameters::_internal_set_presolve_blocked_clause(bool value) {
5098  _has_bits_[3] |= 0x00000004u;
5099  presolve_blocked_clause_ = value;
5100 }
5101 inline void SatParameters::set_presolve_blocked_clause(bool value) {
5102  _internal_set_presolve_blocked_clause(value);
5103  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_blocked_clause)
5104 }
5105 
5106 // optional bool presolve_use_bva = 72 [default = true];
5107 inline bool SatParameters::_internal_has_presolve_use_bva() const {
5108  bool value = (_has_bits_[3] & 0x00000008u) != 0;
5109  return value;
5110 }
5111 inline bool SatParameters::has_presolve_use_bva() const {
5112  return _internal_has_presolve_use_bva();
5113 }
5114 inline void SatParameters::clear_presolve_use_bva() {
5115  presolve_use_bva_ = true;
5116  _has_bits_[3] &= ~0x00000008u;
5117 }
5118 inline bool SatParameters::_internal_presolve_use_bva() const {
5119  return presolve_use_bva_;
5120 }
5121 inline bool SatParameters::presolve_use_bva() const {
5122  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_use_bva)
5123  return _internal_presolve_use_bva();
5124 }
5125 inline void SatParameters::_internal_set_presolve_use_bva(bool value) {
5126  _has_bits_[3] |= 0x00000008u;
5127  presolve_use_bva_ = value;
5128 }
5129 inline void SatParameters::set_presolve_use_bva(bool value) {
5130  _internal_set_presolve_use_bva(value);
5131  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_use_bva)
5132 }
5133 
5134 // optional int32 presolve_bva_threshold = 73 [default = 1];
5135 inline bool SatParameters::_internal_has_presolve_bva_threshold() const {
5136  bool value = (_has_bits_[3] & 0x00000001u) != 0;
5137  return value;
5138 }
5139 inline bool SatParameters::has_presolve_bva_threshold() const {
5140  return _internal_has_presolve_bva_threshold();
5141 }
5142 inline void SatParameters::clear_presolve_bva_threshold() {
5143  presolve_bva_threshold_ = 1;
5144  _has_bits_[3] &= ~0x00000001u;
5145 }
5146 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_bva_threshold() const {
5147  return presolve_bva_threshold_;
5148 }
5149 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_bva_threshold() const {
5150  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_bva_threshold)
5151  return _internal_presolve_bva_threshold();
5152 }
5153 inline void SatParameters::_internal_set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
5154  _has_bits_[3] |= 0x00000001u;
5155  presolve_bva_threshold_ = value;
5156 }
5157 inline void SatParameters::set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value) {
5158  _internal_set_presolve_bva_threshold(value);
5159  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_bva_threshold)
5160 }
5161 
5162 // optional int32 max_presolve_iterations = 138 [default = 3];
5163 inline bool SatParameters::_internal_has_max_presolve_iterations() const {
5164  bool value = (_has_bits_[4] & 0x00000200u) != 0;
5165  return value;
5166 }
5167 inline bool SatParameters::has_max_presolve_iterations() const {
5168  return _internal_has_max_presolve_iterations();
5169 }
5170 inline void SatParameters::clear_max_presolve_iterations() {
5171  max_presolve_iterations_ = 3;
5172  _has_bits_[4] &= ~0x00000200u;
5173 }
5174 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_presolve_iterations() const {
5175  return max_presolve_iterations_;
5176 }
5177 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_presolve_iterations() const {
5178  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_presolve_iterations)
5179  return _internal_max_presolve_iterations();
5180 }
5181 inline void SatParameters::_internal_set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value) {
5182  _has_bits_[4] |= 0x00000200u;
5183  max_presolve_iterations_ = value;
5184 }
5185 inline void SatParameters::set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value) {
5186  _internal_set_max_presolve_iterations(value);
5187  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_presolve_iterations)
5188 }
5189 
5190 // optional bool cp_model_presolve = 86 [default = true];
5191 inline bool SatParameters::_internal_has_cp_model_presolve() const {
5192  bool value = (_has_bits_[3] & 0x00000010u) != 0;
5193  return value;
5194 }
5195 inline bool SatParameters::has_cp_model_presolve() const {
5196  return _internal_has_cp_model_presolve();
5197 }
5198 inline void SatParameters::clear_cp_model_presolve() {
5199  cp_model_presolve_ = true;
5200  _has_bits_[3] &= ~0x00000010u;
5201 }
5202 inline bool SatParameters::_internal_cp_model_presolve() const {
5203  return cp_model_presolve_;
5204 }
5205 inline bool SatParameters::cp_model_presolve() const {
5206  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_presolve)
5207  return _internal_cp_model_presolve();
5208 }
5209 inline void SatParameters::_internal_set_cp_model_presolve(bool value) {
5210  _has_bits_[3] |= 0x00000010u;
5211  cp_model_presolve_ = value;
5212 }
5213 inline void SatParameters::set_cp_model_presolve(bool value) {
5214  _internal_set_cp_model_presolve(value);
5215  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_presolve)
5216 }
5217 
5218 // optional bool cp_model_postsolve_with_full_solver = 162 [default = false];
5219 inline bool SatParameters::_internal_has_cp_model_postsolve_with_full_solver() const {
5220  bool value = (_has_bits_[0] & 0x00800000u) != 0;
5221  return value;
5222 }
5223 inline bool SatParameters::has_cp_model_postsolve_with_full_solver() const {
5224  return _internal_has_cp_model_postsolve_with_full_solver();
5225 }
5226 inline void SatParameters::clear_cp_model_postsolve_with_full_solver() {
5227  cp_model_postsolve_with_full_solver_ = false;
5228  _has_bits_[0] &= ~0x00800000u;
5229 }
5230 inline bool SatParameters::_internal_cp_model_postsolve_with_full_solver() const {
5231  return cp_model_postsolve_with_full_solver_;
5232 }
5233 inline bool SatParameters::cp_model_postsolve_with_full_solver() const {
5234  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_postsolve_with_full_solver)
5235  return _internal_cp_model_postsolve_with_full_solver();
5236 }
5237 inline void SatParameters::_internal_set_cp_model_postsolve_with_full_solver(bool value) {
5238  _has_bits_[0] |= 0x00800000u;
5239  cp_model_postsolve_with_full_solver_ = value;
5240 }
5241 inline void SatParameters::set_cp_model_postsolve_with_full_solver(bool value) {
5242  _internal_set_cp_model_postsolve_with_full_solver(value);
5243  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_postsolve_with_full_solver)
5244 }
5245 
5246 // optional int32 cp_model_max_num_presolve_operations = 151 [default = 0];
5247 inline bool SatParameters::_internal_has_cp_model_max_num_presolve_operations() const {
5248  bool value = (_has_bits_[1] & 0x00040000u) != 0;
5249  return value;
5250 }
5251 inline bool SatParameters::has_cp_model_max_num_presolve_operations() const {
5252  return _internal_has_cp_model_max_num_presolve_operations();
5253 }
5254 inline void SatParameters::clear_cp_model_max_num_presolve_operations() {
5255  cp_model_max_num_presolve_operations_ = 0;
5256  _has_bits_[1] &= ~0x00040000u;
5257 }
5258 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cp_model_max_num_presolve_operations() const {
5259  return cp_model_max_num_presolve_operations_;
5260 }
5261 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cp_model_max_num_presolve_operations() const {
5262  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_max_num_presolve_operations)
5263  return _internal_cp_model_max_num_presolve_operations();
5264 }
5265 inline void SatParameters::_internal_set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value) {
5266  _has_bits_[1] |= 0x00040000u;
5267  cp_model_max_num_presolve_operations_ = value;
5268 }
5269 inline void SatParameters::set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value) {
5270  _internal_set_cp_model_max_num_presolve_operations(value);
5271  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_max_num_presolve_operations)
5272 }
5273 
5274 // optional int32 cp_model_probing_level = 110 [default = 2];
5275 inline bool SatParameters::_internal_has_cp_model_probing_level() const {
5276  bool value = (_has_bits_[3] & 0x00020000u) != 0;
5277  return value;
5278 }
5279 inline bool SatParameters::has_cp_model_probing_level() const {
5280  return _internal_has_cp_model_probing_level();
5281 }
5282 inline void SatParameters::clear_cp_model_probing_level() {
5283  cp_model_probing_level_ = 2;
5284  _has_bits_[3] &= ~0x00020000u;
5285 }
5286 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cp_model_probing_level() const {
5287  return cp_model_probing_level_;
5288 }
5289 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cp_model_probing_level() const {
5290  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_probing_level)
5291  return _internal_cp_model_probing_level();
5292 }
5293 inline void SatParameters::_internal_set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5294  _has_bits_[3] |= 0x00020000u;
5295  cp_model_probing_level_ = value;
5296 }
5297 inline void SatParameters::set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5298  _internal_set_cp_model_probing_level(value);
5299  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_probing_level)
5300 }
5301 
5302 // optional bool cp_model_use_sat_presolve = 93 [default = true];
5303 inline bool SatParameters::_internal_has_cp_model_use_sat_presolve() const {
5304  bool value = (_has_bits_[3] & 0x00000020u) != 0;
5305  return value;
5306 }
5307 inline bool SatParameters::has_cp_model_use_sat_presolve() const {
5308  return _internal_has_cp_model_use_sat_presolve();
5309 }
5310 inline void SatParameters::clear_cp_model_use_sat_presolve() {
5311  cp_model_use_sat_presolve_ = true;
5312  _has_bits_[3] &= ~0x00000020u;
5313 }
5314 inline bool SatParameters::_internal_cp_model_use_sat_presolve() const {
5315  return cp_model_use_sat_presolve_;
5316 }
5317 inline bool SatParameters::cp_model_use_sat_presolve() const {
5318  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
5319  return _internal_cp_model_use_sat_presolve();
5320 }
5321 inline void SatParameters::_internal_set_cp_model_use_sat_presolve(bool value) {
5322  _has_bits_[3] |= 0x00000020u;
5323  cp_model_use_sat_presolve_ = value;
5324 }
5325 inline void SatParameters::set_cp_model_use_sat_presolve(bool value) {
5326  _internal_set_cp_model_use_sat_presolve(value);
5327  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cp_model_use_sat_presolve)
5328 }
5329 
5330 // optional bool use_sat_inprocessing = 163 [default = false];
5331 inline bool SatParameters::_internal_has_use_sat_inprocessing() const {
5332  bool value = (_has_bits_[0] & 0x01000000u) != 0;
5333  return value;
5334 }
5335 inline bool SatParameters::has_use_sat_inprocessing() const {
5336  return _internal_has_use_sat_inprocessing();
5337 }
5338 inline void SatParameters::clear_use_sat_inprocessing() {
5339  use_sat_inprocessing_ = false;
5340  _has_bits_[0] &= ~0x01000000u;
5341 }
5342 inline bool SatParameters::_internal_use_sat_inprocessing() const {
5343  return use_sat_inprocessing_;
5344 }
5345 inline bool SatParameters::use_sat_inprocessing() const {
5346  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_sat_inprocessing)
5347  return _internal_use_sat_inprocessing();
5348 }
5349 inline void SatParameters::_internal_set_use_sat_inprocessing(bool value) {
5350  _has_bits_[0] |= 0x01000000u;
5351  use_sat_inprocessing_ = value;
5352 }
5353 inline void SatParameters::set_use_sat_inprocessing(bool value) {
5354  _internal_set_use_sat_inprocessing(value);
5355  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_sat_inprocessing)
5356 }
5357 
5358 // optional bool expand_element_constraints = 140 [default = true];
5359 inline bool SatParameters::_internal_has_expand_element_constraints() const {
5360  bool value = (_has_bits_[4] & 0x01000000u) != 0;
5361  return value;
5362 }
5363 inline bool SatParameters::has_expand_element_constraints() const {
5364  return _internal_has_expand_element_constraints();
5365 }
5366 inline void SatParameters::clear_expand_element_constraints() {
5367  expand_element_constraints_ = true;
5368  _has_bits_[4] &= ~0x01000000u;
5369 }
5370 inline bool SatParameters::_internal_expand_element_constraints() const {
5371  return expand_element_constraints_;
5372 }
5373 inline bool SatParameters::expand_element_constraints() const {
5374  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_element_constraints)
5375  return _internal_expand_element_constraints();
5376 }
5377 inline void SatParameters::_internal_set_expand_element_constraints(bool value) {
5378  _has_bits_[4] |= 0x01000000u;
5379  expand_element_constraints_ = value;
5380 }
5381 inline void SatParameters::set_expand_element_constraints(bool value) {
5382  _internal_set_expand_element_constraints(value);
5383  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_element_constraints)
5384 }
5385 
5386 // optional bool expand_automaton_constraints = 143 [default = true];
5387 inline bool SatParameters::_internal_has_expand_automaton_constraints() const {
5388  bool value = (_has_bits_[4] & 0x02000000u) != 0;
5389  return value;
5390 }
5391 inline bool SatParameters::has_expand_automaton_constraints() const {
5392  return _internal_has_expand_automaton_constraints();
5393 }
5394 inline void SatParameters::clear_expand_automaton_constraints() {
5395  expand_automaton_constraints_ = true;
5396  _has_bits_[4] &= ~0x02000000u;
5397 }
5398 inline bool SatParameters::_internal_expand_automaton_constraints() const {
5399  return expand_automaton_constraints_;
5400 }
5401 inline bool SatParameters::expand_automaton_constraints() const {
5402  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_automaton_constraints)
5403  return _internal_expand_automaton_constraints();
5404 }
5405 inline void SatParameters::_internal_set_expand_automaton_constraints(bool value) {
5406  _has_bits_[4] |= 0x02000000u;
5407  expand_automaton_constraints_ = value;
5408 }
5409 inline void SatParameters::set_expand_automaton_constraints(bool value) {
5410  _internal_set_expand_automaton_constraints(value);
5411  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_automaton_constraints)
5412 }
5413 
5414 // optional bool expand_table_constraints = 158 [default = true];
5415 inline bool SatParameters::_internal_has_expand_table_constraints() const {
5416  bool value = (_has_bits_[4] & 0x04000000u) != 0;
5417  return value;
5418 }
5419 inline bool SatParameters::has_expand_table_constraints() const {
5420  return _internal_has_expand_table_constraints();
5421 }
5422 inline void SatParameters::clear_expand_table_constraints() {
5423  expand_table_constraints_ = true;
5424  _has_bits_[4] &= ~0x04000000u;
5425 }
5426 inline bool SatParameters::_internal_expand_table_constraints() const {
5427  return expand_table_constraints_;
5428 }
5429 inline bool SatParameters::expand_table_constraints() const {
5430  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_table_constraints)
5431  return _internal_expand_table_constraints();
5432 }
5433 inline void SatParameters::_internal_set_expand_table_constraints(bool value) {
5434  _has_bits_[4] |= 0x04000000u;
5435  expand_table_constraints_ = value;
5436 }
5437 inline void SatParameters::set_expand_table_constraints(bool value) {
5438  _internal_set_expand_table_constraints(value);
5439  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_table_constraints)
5440 }
5441 
5442 // optional bool expand_alldiff_constraints = 170 [default = false];
5443 inline bool SatParameters::_internal_has_expand_alldiff_constraints() const {
5444  bool value = (_has_bits_[1] & 0x00000200u) != 0;
5445  return value;
5446 }
5447 inline bool SatParameters::has_expand_alldiff_constraints() const {
5448  return _internal_has_expand_alldiff_constraints();
5449 }
5450 inline void SatParameters::clear_expand_alldiff_constraints() {
5451  expand_alldiff_constraints_ = false;
5452  _has_bits_[1] &= ~0x00000200u;
5453 }
5454 inline bool SatParameters::_internal_expand_alldiff_constraints() const {
5455  return expand_alldiff_constraints_;
5456 }
5457 inline bool SatParameters::expand_alldiff_constraints() const {
5458  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_alldiff_constraints)
5459  return _internal_expand_alldiff_constraints();
5460 }
5461 inline void SatParameters::_internal_set_expand_alldiff_constraints(bool value) {
5462  _has_bits_[1] |= 0x00000200u;
5463  expand_alldiff_constraints_ = value;
5464 }
5465 inline void SatParameters::set_expand_alldiff_constraints(bool value) {
5466  _internal_set_expand_alldiff_constraints(value);
5467  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_alldiff_constraints)
5468 }
5469 
5470 // optional bool expand_reservoir_constraints = 182 [default = true];
5471 inline bool SatParameters::_internal_has_expand_reservoir_constraints() const {
5472  bool value = (_has_bits_[4] & 0x08000000u) != 0;
5473  return value;
5474 }
5475 inline bool SatParameters::has_expand_reservoir_constraints() const {
5476  return _internal_has_expand_reservoir_constraints();
5477 }
5478 inline void SatParameters::clear_expand_reservoir_constraints() {
5479  expand_reservoir_constraints_ = true;
5480  _has_bits_[4] &= ~0x08000000u;
5481 }
5482 inline bool SatParameters::_internal_expand_reservoir_constraints() const {
5483  return expand_reservoir_constraints_;
5484 }
5485 inline bool SatParameters::expand_reservoir_constraints() const {
5486  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.expand_reservoir_constraints)
5487  return _internal_expand_reservoir_constraints();
5488 }
5489 inline void SatParameters::_internal_set_expand_reservoir_constraints(bool value) {
5490  _has_bits_[4] |= 0x08000000u;
5491  expand_reservoir_constraints_ = value;
5492 }
5493 inline void SatParameters::set_expand_reservoir_constraints(bool value) {
5494  _internal_set_expand_reservoir_constraints(value);
5495  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.expand_reservoir_constraints)
5496 }
5497 
5498 // optional bool disable_constraint_expansion = 181 [default = false];
5499 inline bool SatParameters::_internal_has_disable_constraint_expansion() const {
5500  bool value = (_has_bits_[1] & 0x00000400u) != 0;
5501  return value;
5502 }
5503 inline bool SatParameters::has_disable_constraint_expansion() const {
5504  return _internal_has_disable_constraint_expansion();
5505 }
5506 inline void SatParameters::clear_disable_constraint_expansion() {
5507  disable_constraint_expansion_ = false;
5508  _has_bits_[1] &= ~0x00000400u;
5509 }
5510 inline bool SatParameters::_internal_disable_constraint_expansion() const {
5511  return disable_constraint_expansion_;
5512 }
5513 inline bool SatParameters::disable_constraint_expansion() const {
5514  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.disable_constraint_expansion)
5515  return _internal_disable_constraint_expansion();
5516 }
5517 inline void SatParameters::_internal_set_disable_constraint_expansion(bool value) {
5518  _has_bits_[1] |= 0x00000400u;
5519  disable_constraint_expansion_ = value;
5520 }
5521 inline void SatParameters::set_disable_constraint_expansion(bool value) {
5522  _internal_set_disable_constraint_expansion(value);
5523  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.disable_constraint_expansion)
5524 }
5525 
5526 // optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
5527 inline bool SatParameters::_internal_has_merge_no_overlap_work_limit() const {
5528  bool value = (_has_bits_[4] & 0x00000800u) != 0;
5529  return value;
5530 }
5531 inline bool SatParameters::has_merge_no_overlap_work_limit() const {
5532  return _internal_has_merge_no_overlap_work_limit();
5533 }
5534 inline void SatParameters::clear_merge_no_overlap_work_limit() {
5535  merge_no_overlap_work_limit_ = 1000000000000;
5536  _has_bits_[4] &= ~0x00000800u;
5537 }
5538 inline double SatParameters::_internal_merge_no_overlap_work_limit() const {
5539  return merge_no_overlap_work_limit_;
5540 }
5541 inline double SatParameters::merge_no_overlap_work_limit() const {
5542  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.merge_no_overlap_work_limit)
5543  return _internal_merge_no_overlap_work_limit();
5544 }
5545 inline void SatParameters::_internal_set_merge_no_overlap_work_limit(double value) {
5546  _has_bits_[4] |= 0x00000800u;
5547  merge_no_overlap_work_limit_ = value;
5548 }
5549 inline void SatParameters::set_merge_no_overlap_work_limit(double value) {
5550  _internal_set_merge_no_overlap_work_limit(value);
5551  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.merge_no_overlap_work_limit)
5552 }
5553 
5554 // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
5555 inline bool SatParameters::_internal_has_merge_at_most_one_work_limit() const {
5556  bool value = (_has_bits_[4] & 0x00001000u) != 0;
5557  return value;
5558 }
5559 inline bool SatParameters::has_merge_at_most_one_work_limit() const {
5560  return _internal_has_merge_at_most_one_work_limit();
5561 }
5562 inline void SatParameters::clear_merge_at_most_one_work_limit() {
5563  merge_at_most_one_work_limit_ = 100000000;
5564  _has_bits_[4] &= ~0x00001000u;
5565 }
5566 inline double SatParameters::_internal_merge_at_most_one_work_limit() const {
5567  return merge_at_most_one_work_limit_;
5568 }
5569 inline double SatParameters::merge_at_most_one_work_limit() const {
5570  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.merge_at_most_one_work_limit)
5571  return _internal_merge_at_most_one_work_limit();
5572 }
5573 inline void SatParameters::_internal_set_merge_at_most_one_work_limit(double value) {
5574  _has_bits_[4] |= 0x00001000u;
5575  merge_at_most_one_work_limit_ = value;
5576 }
5577 inline void SatParameters::set_merge_at_most_one_work_limit(double value) {
5578  _internal_set_merge_at_most_one_work_limit(value);
5579  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.merge_at_most_one_work_limit)
5580 }
5581 
5582 // optional int32 presolve_substitution_level = 147 [default = 1];
5583 inline bool SatParameters::_internal_has_presolve_substitution_level() const {
5584  bool value = (_has_bits_[4] & 0x00000400u) != 0;
5585  return value;
5586 }
5587 inline bool SatParameters::has_presolve_substitution_level() const {
5588  return _internal_has_presolve_substitution_level();
5589 }
5590 inline void SatParameters::clear_presolve_substitution_level() {
5591  presolve_substitution_level_ = 1;
5592  _has_bits_[4] &= ~0x00000400u;
5593 }
5594 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_presolve_substitution_level() const {
5595  return presolve_substitution_level_;
5596 }
5597 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::presolve_substitution_level() const {
5598  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_substitution_level)
5599  return _internal_presolve_substitution_level();
5600 }
5601 inline void SatParameters::_internal_set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5602  _has_bits_[4] |= 0x00000400u;
5603  presolve_substitution_level_ = value;
5604 }
5605 inline void SatParameters::set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5606  _internal_set_presolve_substitution_level(value);
5607  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_substitution_level)
5608 }
5609 
5610 // optional bool presolve_extract_integer_enforcement = 174 [default = false];
5611 inline bool SatParameters::_internal_has_presolve_extract_integer_enforcement() const {
5612  bool value = (_has_bits_[1] & 0x00000800u) != 0;
5613  return value;
5614 }
5615 inline bool SatParameters::has_presolve_extract_integer_enforcement() const {
5616  return _internal_has_presolve_extract_integer_enforcement();
5617 }
5618 inline void SatParameters::clear_presolve_extract_integer_enforcement() {
5619  presolve_extract_integer_enforcement_ = false;
5620  _has_bits_[1] &= ~0x00000800u;
5621 }
5622 inline bool SatParameters::_internal_presolve_extract_integer_enforcement() const {
5623  return presolve_extract_integer_enforcement_;
5624 }
5625 inline bool SatParameters::presolve_extract_integer_enforcement() const {
5626  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.presolve_extract_integer_enforcement)
5627  return _internal_presolve_extract_integer_enforcement();
5628 }
5629 inline void SatParameters::_internal_set_presolve_extract_integer_enforcement(bool value) {
5630  _has_bits_[1] |= 0x00000800u;
5631  presolve_extract_integer_enforcement_ = value;
5632 }
5633 inline void SatParameters::set_presolve_extract_integer_enforcement(bool value) {
5634  _internal_set_presolve_extract_integer_enforcement(value);
5635  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.presolve_extract_integer_enforcement)
5636 }
5637 
5638 // optional bool use_optimization_hints = 35 [default = true];
5639 inline bool SatParameters::_internal_has_use_optimization_hints() const {
5640  bool value = (_has_bits_[2] & 0x02000000u) != 0;
5641  return value;
5642 }
5643 inline bool SatParameters::has_use_optimization_hints() const {
5644  return _internal_has_use_optimization_hints();
5645 }
5646 inline void SatParameters::clear_use_optimization_hints() {
5647  use_optimization_hints_ = true;
5648  _has_bits_[2] &= ~0x02000000u;
5649 }
5650 inline bool SatParameters::_internal_use_optimization_hints() const {
5651  return use_optimization_hints_;
5652 }
5653 inline bool SatParameters::use_optimization_hints() const {
5654  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_optimization_hints)
5655  return _internal_use_optimization_hints();
5656 }
5657 inline void SatParameters::_internal_set_use_optimization_hints(bool value) {
5658  _has_bits_[2] |= 0x02000000u;
5659  use_optimization_hints_ = value;
5660 }
5661 inline void SatParameters::set_use_optimization_hints(bool value) {
5662  _internal_set_use_optimization_hints(value);
5663  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_optimization_hints)
5664 }
5665 
5666 // optional bool minimize_core = 50 [default = true];
5667 inline bool SatParameters::_internal_has_minimize_core() const {
5668  bool value = (_has_bits_[2] & 0x04000000u) != 0;
5669  return value;
5670 }
5671 inline bool SatParameters::has_minimize_core() const {
5672  return _internal_has_minimize_core();
5673 }
5674 inline void SatParameters::clear_minimize_core() {
5675  minimize_core_ = true;
5676  _has_bits_[2] &= ~0x04000000u;
5677 }
5678 inline bool SatParameters::_internal_minimize_core() const {
5679  return minimize_core_;
5680 }
5681 inline bool SatParameters::minimize_core() const {
5682  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.minimize_core)
5683  return _internal_minimize_core();
5684 }
5685 inline void SatParameters::_internal_set_minimize_core(bool value) {
5686  _has_bits_[2] |= 0x04000000u;
5687  minimize_core_ = value;
5688 }
5689 inline void SatParameters::set_minimize_core(bool value) {
5690  _internal_set_minimize_core(value);
5691  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.minimize_core)
5692 }
5693 
5694 // optional bool find_multiple_cores = 84 [default = true];
5695 inline bool SatParameters::_internal_has_find_multiple_cores() const {
5696  bool value = (_has_bits_[2] & 0x08000000u) != 0;
5697  return value;
5698 }
5699 inline bool SatParameters::has_find_multiple_cores() const {
5700  return _internal_has_find_multiple_cores();
5701 }
5702 inline void SatParameters::clear_find_multiple_cores() {
5703  find_multiple_cores_ = true;
5704  _has_bits_[2] &= ~0x08000000u;
5705 }
5706 inline bool SatParameters::_internal_find_multiple_cores() const {
5707  return find_multiple_cores_;
5708 }
5709 inline bool SatParameters::find_multiple_cores() const {
5710  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.find_multiple_cores)
5711  return _internal_find_multiple_cores();
5712 }
5713 inline void SatParameters::_internal_set_find_multiple_cores(bool value) {
5714  _has_bits_[2] |= 0x08000000u;
5715  find_multiple_cores_ = value;
5716 }
5717 inline void SatParameters::set_find_multiple_cores(bool value) {
5718  _internal_set_find_multiple_cores(value);
5719  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.find_multiple_cores)
5720 }
5721 
5722 // optional bool cover_optimization = 89 [default = true];
5723 inline bool SatParameters::_internal_has_cover_optimization() const {
5724  bool value = (_has_bits_[2] & 0x10000000u) != 0;
5725  return value;
5726 }
5727 inline bool SatParameters::has_cover_optimization() const {
5728  return _internal_has_cover_optimization();
5729 }
5730 inline void SatParameters::clear_cover_optimization() {
5731  cover_optimization_ = true;
5732  _has_bits_[2] &= ~0x10000000u;
5733 }
5734 inline bool SatParameters::_internal_cover_optimization() const {
5735  return cover_optimization_;
5736 }
5737 inline bool SatParameters::cover_optimization() const {
5738  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cover_optimization)
5739  return _internal_cover_optimization();
5740 }
5741 inline void SatParameters::_internal_set_cover_optimization(bool value) {
5742  _has_bits_[2] |= 0x10000000u;
5743  cover_optimization_ = value;
5744 }
5745 inline void SatParameters::set_cover_optimization(bool value) {
5746  _internal_set_cover_optimization(value);
5747  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cover_optimization)
5748 }
5749 
5750 // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
5751 inline bool SatParameters::_internal_has_max_sat_assumption_order() const {
5752  bool value = (_has_bits_[0] & 0x00000008u) != 0;
5753  return value;
5754 }
5755 inline bool SatParameters::has_max_sat_assumption_order() const {
5756  return _internal_has_max_sat_assumption_order();
5757 }
5758 inline void SatParameters::clear_max_sat_assumption_order() {
5759  max_sat_assumption_order_ = 0;
5760  _has_bits_[0] &= ~0x00000008u;
5761 }
5762 inline ::operations_research::sat::SatParameters_MaxSatAssumptionOrder SatParameters::_internal_max_sat_assumption_order() const {
5763  return static_cast< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder >(max_sat_assumption_order_);
5764 }
5765 inline ::operations_research::sat::SatParameters_MaxSatAssumptionOrder SatParameters::max_sat_assumption_order() const {
5766  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_assumption_order)
5767  return _internal_max_sat_assumption_order();
5768 }
5769 inline void SatParameters::_internal_set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value) {
5770  assert(::operations_research::sat::SatParameters_MaxSatAssumptionOrder_IsValid(value));
5771  _has_bits_[0] |= 0x00000008u;
5772  max_sat_assumption_order_ = value;
5773 }
5774 inline void SatParameters::set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value) {
5775  _internal_set_max_sat_assumption_order(value);
5776  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_assumption_order)
5777 }
5778 
5779 // optional bool max_sat_reverse_assumption_order = 52 [default = false];
5780 inline bool SatParameters::_internal_has_max_sat_reverse_assumption_order() const {
5781  bool value = (_has_bits_[1] & 0x00001000u) != 0;
5782  return value;
5783 }
5784 inline bool SatParameters::has_max_sat_reverse_assumption_order() const {
5785  return _internal_has_max_sat_reverse_assumption_order();
5786 }
5787 inline void SatParameters::clear_max_sat_reverse_assumption_order() {
5788  max_sat_reverse_assumption_order_ = false;
5789  _has_bits_[1] &= ~0x00001000u;
5790 }
5791 inline bool SatParameters::_internal_max_sat_reverse_assumption_order() const {
5792  return max_sat_reverse_assumption_order_;
5793 }
5794 inline bool SatParameters::max_sat_reverse_assumption_order() const {
5795  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_reverse_assumption_order)
5796  return _internal_max_sat_reverse_assumption_order();
5797 }
5798 inline void SatParameters::_internal_set_max_sat_reverse_assumption_order(bool value) {
5799  _has_bits_[1] |= 0x00001000u;
5800  max_sat_reverse_assumption_order_ = value;
5801 }
5802 inline void SatParameters::set_max_sat_reverse_assumption_order(bool value) {
5803  _internal_set_max_sat_reverse_assumption_order(value);
5804  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_reverse_assumption_order)
5805 }
5806 
5807 // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
5808 inline bool SatParameters::_internal_has_max_sat_stratification() const {
5809  bool value = (_has_bits_[2] & 0x00040000u) != 0;
5810  return value;
5811 }
5812 inline bool SatParameters::has_max_sat_stratification() const {
5813  return _internal_has_max_sat_stratification();
5814 }
5815 inline void SatParameters::clear_max_sat_stratification() {
5816  max_sat_stratification_ = 1;
5817  _has_bits_[2] &= ~0x00040000u;
5818 }
5819 inline ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm SatParameters::_internal_max_sat_stratification() const {
5820  return static_cast< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm >(max_sat_stratification_);
5821 }
5822 inline ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm SatParameters::max_sat_stratification() const {
5823  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_sat_stratification)
5824  return _internal_max_sat_stratification();
5825 }
5826 inline void SatParameters::_internal_set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
5827  assert(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_IsValid(value));
5828  _has_bits_[2] |= 0x00040000u;
5829  max_sat_stratification_ = value;
5830 }
5831 inline void SatParameters::set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value) {
5832  _internal_set_max_sat_stratification(value);
5833  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_sat_stratification)
5834 }
5835 
5836 // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
5837 inline bool SatParameters::_internal_has_use_precedences_in_disjunctive_constraint() const {
5838  bool value = (_has_bits_[3] & 0x00000400u) != 0;
5839  return value;
5840 }
5841 inline bool SatParameters::has_use_precedences_in_disjunctive_constraint() const {
5842  return _internal_has_use_precedences_in_disjunctive_constraint();
5843 }
5844 inline void SatParameters::clear_use_precedences_in_disjunctive_constraint() {
5845  use_precedences_in_disjunctive_constraint_ = true;
5846  _has_bits_[3] &= ~0x00000400u;
5847 }
5848 inline bool SatParameters::_internal_use_precedences_in_disjunctive_constraint() const {
5849  return use_precedences_in_disjunctive_constraint_;
5850 }
5851 inline bool SatParameters::use_precedences_in_disjunctive_constraint() const {
5852  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_precedences_in_disjunctive_constraint)
5853  return _internal_use_precedences_in_disjunctive_constraint();
5854 }
5855 inline void SatParameters::_internal_set_use_precedences_in_disjunctive_constraint(bool value) {
5856  _has_bits_[3] |= 0x00000400u;
5857  use_precedences_in_disjunctive_constraint_ = value;
5858 }
5859 inline void SatParameters::set_use_precedences_in_disjunctive_constraint(bool value) {
5860  _internal_set_use_precedences_in_disjunctive_constraint(value);
5861  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_precedences_in_disjunctive_constraint)
5862 }
5863 
5864 // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
5865 inline bool SatParameters::_internal_has_use_overload_checker_in_cumulative_constraint() const {
5866  bool value = (_has_bits_[0] & 0x00001000u) != 0;
5867  return value;
5868 }
5869 inline bool SatParameters::has_use_overload_checker_in_cumulative_constraint() const {
5870  return _internal_has_use_overload_checker_in_cumulative_constraint();
5871 }
5872 inline void SatParameters::clear_use_overload_checker_in_cumulative_constraint() {
5873  use_overload_checker_in_cumulative_constraint_ = false;
5874  _has_bits_[0] &= ~0x00001000u;
5875 }
5876 inline bool SatParameters::_internal_use_overload_checker_in_cumulative_constraint() const {
5877  return use_overload_checker_in_cumulative_constraint_;
5878 }
5879 inline bool SatParameters::use_overload_checker_in_cumulative_constraint() const {
5880  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_overload_checker_in_cumulative_constraint)
5881  return _internal_use_overload_checker_in_cumulative_constraint();
5882 }
5883 inline void SatParameters::_internal_set_use_overload_checker_in_cumulative_constraint(bool value) {
5884  _has_bits_[0] |= 0x00001000u;
5885  use_overload_checker_in_cumulative_constraint_ = value;
5886 }
5887 inline void SatParameters::set_use_overload_checker_in_cumulative_constraint(bool value) {
5888  _internal_set_use_overload_checker_in_cumulative_constraint(value);
5889  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_overload_checker_in_cumulative_constraint)
5890 }
5891 
5892 // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
5893 inline bool SatParameters::_internal_has_use_timetable_edge_finding_in_cumulative_constraint() const {
5894  bool value = (_has_bits_[0] & 0x00002000u) != 0;
5895  return value;
5896 }
5897 inline bool SatParameters::has_use_timetable_edge_finding_in_cumulative_constraint() const {
5898  return _internal_has_use_timetable_edge_finding_in_cumulative_constraint();
5899 }
5900 inline void SatParameters::clear_use_timetable_edge_finding_in_cumulative_constraint() {
5901  use_timetable_edge_finding_in_cumulative_constraint_ = false;
5902  _has_bits_[0] &= ~0x00002000u;
5903 }
5904 inline bool SatParameters::_internal_use_timetable_edge_finding_in_cumulative_constraint() const {
5905  return use_timetable_edge_finding_in_cumulative_constraint_;
5906 }
5907 inline bool SatParameters::use_timetable_edge_finding_in_cumulative_constraint() const {
5908  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_timetable_edge_finding_in_cumulative_constraint)
5909  return _internal_use_timetable_edge_finding_in_cumulative_constraint();
5910 }
5911 inline void SatParameters::_internal_set_use_timetable_edge_finding_in_cumulative_constraint(bool value) {
5912  _has_bits_[0] |= 0x00002000u;
5913  use_timetable_edge_finding_in_cumulative_constraint_ = value;
5914 }
5915 inline void SatParameters::set_use_timetable_edge_finding_in_cumulative_constraint(bool value) {
5916  _internal_set_use_timetable_edge_finding_in_cumulative_constraint(value);
5917  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_timetable_edge_finding_in_cumulative_constraint)
5918 }
5919 
5920 // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
5921 inline bool SatParameters::_internal_has_use_disjunctive_constraint_in_cumulative_constraint() const {
5922  bool value = (_has_bits_[3] & 0x00000800u) != 0;
5923  return value;
5924 }
5925 inline bool SatParameters::has_use_disjunctive_constraint_in_cumulative_constraint() const {
5926  return _internal_has_use_disjunctive_constraint_in_cumulative_constraint();
5927 }
5928 inline void SatParameters::clear_use_disjunctive_constraint_in_cumulative_constraint() {
5929  use_disjunctive_constraint_in_cumulative_constraint_ = true;
5930  _has_bits_[3] &= ~0x00000800u;
5931 }
5932 inline bool SatParameters::_internal_use_disjunctive_constraint_in_cumulative_constraint() const {
5933  return use_disjunctive_constraint_in_cumulative_constraint_;
5934 }
5935 inline bool SatParameters::use_disjunctive_constraint_in_cumulative_constraint() const {
5936  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_disjunctive_constraint_in_cumulative_constraint)
5937  return _internal_use_disjunctive_constraint_in_cumulative_constraint();
5938 }
5939 inline void SatParameters::_internal_set_use_disjunctive_constraint_in_cumulative_constraint(bool value) {
5940  _has_bits_[3] |= 0x00000800u;
5941  use_disjunctive_constraint_in_cumulative_constraint_ = value;
5942 }
5943 inline void SatParameters::set_use_disjunctive_constraint_in_cumulative_constraint(bool value) {
5944  _internal_set_use_disjunctive_constraint_in_cumulative_constraint(value);
5945  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_disjunctive_constraint_in_cumulative_constraint)
5946 }
5947 
5948 // optional int32 linearization_level = 90 [default = 1];
5949 inline bool SatParameters::_internal_has_linearization_level() const {
5950  bool value = (_has_bits_[3] & 0x00000040u) != 0;
5951  return value;
5952 }
5953 inline bool SatParameters::has_linearization_level() const {
5954  return _internal_has_linearization_level();
5955 }
5956 inline void SatParameters::clear_linearization_level() {
5957  linearization_level_ = 1;
5958  _has_bits_[3] &= ~0x00000040u;
5959 }
5960 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_linearization_level() const {
5961  return linearization_level_;
5962 }
5963 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::linearization_level() const {
5964  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.linearization_level)
5965  return _internal_linearization_level();
5966 }
5967 inline void SatParameters::_internal_set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5968  _has_bits_[3] |= 0x00000040u;
5969  linearization_level_ = value;
5970 }
5971 inline void SatParameters::set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5972  _internal_set_linearization_level(value);
5973  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.linearization_level)
5974 }
5975 
5976 // optional int32 boolean_encoding_level = 107 [default = 1];
5977 inline bool SatParameters::_internal_has_boolean_encoding_level() const {
5978  bool value = (_has_bits_[3] & 0x00010000u) != 0;
5979  return value;
5980 }
5981 inline bool SatParameters::has_boolean_encoding_level() const {
5982  return _internal_has_boolean_encoding_level();
5983 }
5984 inline void SatParameters::clear_boolean_encoding_level() {
5985  boolean_encoding_level_ = 1;
5986  _has_bits_[3] &= ~0x00010000u;
5987 }
5988 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_boolean_encoding_level() const {
5989  return boolean_encoding_level_;
5990 }
5991 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::boolean_encoding_level() const {
5992  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.boolean_encoding_level)
5993  return _internal_boolean_encoding_level();
5994 }
5995 inline void SatParameters::_internal_set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
5996  _has_bits_[3] |= 0x00010000u;
5997  boolean_encoding_level_ = value;
5998 }
5999 inline void SatParameters::set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
6000  _internal_set_boolean_encoding_level(value);
6001  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.boolean_encoding_level)
6002 }
6003 
6004 // optional int32 max_num_cuts = 91 [default = 10000];
6005 inline bool SatParameters::_internal_has_max_num_cuts() const {
6006  bool value = (_has_bits_[3] & 0x00000080u) != 0;
6007  return value;
6008 }
6009 inline bool SatParameters::has_max_num_cuts() const {
6010  return _internal_has_max_num_cuts();
6011 }
6012 inline void SatParameters::clear_max_num_cuts() {
6013  max_num_cuts_ = 10000;
6014  _has_bits_[3] &= ~0x00000080u;
6015 }
6016 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_num_cuts() const {
6017  return max_num_cuts_;
6018 }
6019 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_num_cuts() const {
6020  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_num_cuts)
6021  return _internal_max_num_cuts();
6022 }
6023 inline void SatParameters::_internal_set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value) {
6024  _has_bits_[3] |= 0x00000080u;
6025  max_num_cuts_ = value;
6026 }
6027 inline void SatParameters::set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value) {
6028  _internal_set_max_num_cuts(value);
6029  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_num_cuts)
6030 }
6031 
6032 // optional bool only_add_cuts_at_level_zero = 92 [default = false];
6033 inline bool SatParameters::_internal_has_only_add_cuts_at_level_zero() const {
6034  bool value = (_has_bits_[0] & 0x00004000u) != 0;
6035  return value;
6036 }
6037 inline bool SatParameters::has_only_add_cuts_at_level_zero() const {
6038  return _internal_has_only_add_cuts_at_level_zero();
6039 }
6040 inline void SatParameters::clear_only_add_cuts_at_level_zero() {
6041  only_add_cuts_at_level_zero_ = false;
6042  _has_bits_[0] &= ~0x00004000u;
6043 }
6044 inline bool SatParameters::_internal_only_add_cuts_at_level_zero() const {
6045  return only_add_cuts_at_level_zero_;
6046 }
6047 inline bool SatParameters::only_add_cuts_at_level_zero() const {
6048  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.only_add_cuts_at_level_zero)
6049  return _internal_only_add_cuts_at_level_zero();
6050 }
6051 inline void SatParameters::_internal_set_only_add_cuts_at_level_zero(bool value) {
6052  _has_bits_[0] |= 0x00004000u;
6053  only_add_cuts_at_level_zero_ = value;
6054 }
6055 inline void SatParameters::set_only_add_cuts_at_level_zero(bool value) {
6056  _internal_set_only_add_cuts_at_level_zero(value);
6057  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.only_add_cuts_at_level_zero)
6058 }
6059 
6060 // optional bool add_knapsack_cuts = 111 [default = false];
6061 inline bool SatParameters::_internal_has_add_knapsack_cuts() const {
6062  bool value = (_has_bits_[0] & 0x00008000u) != 0;
6063  return value;
6064 }
6065 inline bool SatParameters::has_add_knapsack_cuts() const {
6066  return _internal_has_add_knapsack_cuts();
6067 }
6068 inline void SatParameters::clear_add_knapsack_cuts() {
6069  add_knapsack_cuts_ = false;
6070  _has_bits_[0] &= ~0x00008000u;
6071 }
6072 inline bool SatParameters::_internal_add_knapsack_cuts() const {
6073  return add_knapsack_cuts_;
6074 }
6075 inline bool SatParameters::add_knapsack_cuts() const {
6076  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_knapsack_cuts)
6077  return _internal_add_knapsack_cuts();
6078 }
6079 inline void SatParameters::_internal_set_add_knapsack_cuts(bool value) {
6080  _has_bits_[0] |= 0x00008000u;
6081  add_knapsack_cuts_ = value;
6082 }
6083 inline void SatParameters::set_add_knapsack_cuts(bool value) {
6084  _internal_set_add_knapsack_cuts(value);
6085  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_knapsack_cuts)
6086 }
6087 
6088 // optional bool add_cg_cuts = 117 [default = true];
6089 inline bool SatParameters::_internal_has_add_cg_cuts() const {
6090  bool value = (_has_bits_[3] & 0x00001000u) != 0;
6091  return value;
6092 }
6093 inline bool SatParameters::has_add_cg_cuts() const {
6094  return _internal_has_add_cg_cuts();
6095 }
6096 inline void SatParameters::clear_add_cg_cuts() {
6097  add_cg_cuts_ = true;
6098  _has_bits_[3] &= ~0x00001000u;
6099 }
6100 inline bool SatParameters::_internal_add_cg_cuts() const {
6101  return add_cg_cuts_;
6102 }
6103 inline bool SatParameters::add_cg_cuts() const {
6104  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_cg_cuts)
6105  return _internal_add_cg_cuts();
6106 }
6107 inline void SatParameters::_internal_set_add_cg_cuts(bool value) {
6108  _has_bits_[3] |= 0x00001000u;
6109  add_cg_cuts_ = value;
6110 }
6111 inline void SatParameters::set_add_cg_cuts(bool value) {
6112  _internal_set_add_cg_cuts(value);
6113  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_cg_cuts)
6114 }
6115 
6116 // optional bool add_mir_cuts = 120 [default = true];
6117 inline bool SatParameters::_internal_has_add_mir_cuts() const {
6118  bool value = (_has_bits_[3] & 0x00002000u) != 0;
6119  return value;
6120 }
6121 inline bool SatParameters::has_add_mir_cuts() const {
6122  return _internal_has_add_mir_cuts();
6123 }
6124 inline void SatParameters::clear_add_mir_cuts() {
6125  add_mir_cuts_ = true;
6126  _has_bits_[3] &= ~0x00002000u;
6127 }
6128 inline bool SatParameters::_internal_add_mir_cuts() const {
6129  return add_mir_cuts_;
6130 }
6131 inline bool SatParameters::add_mir_cuts() const {
6132  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_mir_cuts)
6133  return _internal_add_mir_cuts();
6134 }
6135 inline void SatParameters::_internal_set_add_mir_cuts(bool value) {
6136  _has_bits_[3] |= 0x00002000u;
6137  add_mir_cuts_ = value;
6138 }
6139 inline void SatParameters::set_add_mir_cuts(bool value) {
6140  _internal_set_add_mir_cuts(value);
6141  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_mir_cuts)
6142 }
6143 
6144 // optional bool add_zero_half_cuts = 169 [default = true];
6145 inline bool SatParameters::_internal_has_add_zero_half_cuts() const {
6146  bool value = (_has_bits_[4] & 0x00020000u) != 0;
6147  return value;
6148 }
6149 inline bool SatParameters::has_add_zero_half_cuts() const {
6150  return _internal_has_add_zero_half_cuts();
6151 }
6152 inline void SatParameters::clear_add_zero_half_cuts() {
6153  add_zero_half_cuts_ = true;
6154  _has_bits_[4] &= ~0x00020000u;
6155 }
6156 inline bool SatParameters::_internal_add_zero_half_cuts() const {
6157  return add_zero_half_cuts_;
6158 }
6159 inline bool SatParameters::add_zero_half_cuts() const {
6160  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_zero_half_cuts)
6161  return _internal_add_zero_half_cuts();
6162 }
6163 inline void SatParameters::_internal_set_add_zero_half_cuts(bool value) {
6164  _has_bits_[4] |= 0x00020000u;
6165  add_zero_half_cuts_ = value;
6166 }
6167 inline void SatParameters::set_add_zero_half_cuts(bool value) {
6168  _internal_set_add_zero_half_cuts(value);
6169  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_zero_half_cuts)
6170 }
6171 
6172 // optional bool add_clique_cuts = 172 [default = true];
6173 inline bool SatParameters::_internal_has_add_clique_cuts() const {
6174  bool value = (_has_bits_[4] & 0x00040000u) != 0;
6175  return value;
6176 }
6177 inline bool SatParameters::has_add_clique_cuts() const {
6178  return _internal_has_add_clique_cuts();
6179 }
6180 inline void SatParameters::clear_add_clique_cuts() {
6181  add_clique_cuts_ = true;
6182  _has_bits_[4] &= ~0x00040000u;
6183 }
6184 inline bool SatParameters::_internal_add_clique_cuts() const {
6185  return add_clique_cuts_;
6186 }
6187 inline bool SatParameters::add_clique_cuts() const {
6188  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_clique_cuts)
6189  return _internal_add_clique_cuts();
6190 }
6191 inline void SatParameters::_internal_set_add_clique_cuts(bool value) {
6192  _has_bits_[4] |= 0x00040000u;
6193  add_clique_cuts_ = value;
6194 }
6195 inline void SatParameters::set_add_clique_cuts(bool value) {
6196  _internal_set_add_clique_cuts(value);
6197  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_clique_cuts)
6198 }
6199 
6200 // optional int32 max_all_diff_cut_size = 148 [default = 7];
6201 inline bool SatParameters::_internal_has_max_all_diff_cut_size() const {
6202  bool value = (_has_bits_[4] & 0x00002000u) != 0;
6203  return value;
6204 }
6205 inline bool SatParameters::has_max_all_diff_cut_size() const {
6206  return _internal_has_max_all_diff_cut_size();
6207 }
6208 inline void SatParameters::clear_max_all_diff_cut_size() {
6209  max_all_diff_cut_size_ = 7;
6210  _has_bits_[4] &= ~0x00002000u;
6211 }
6212 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_all_diff_cut_size() const {
6213  return max_all_diff_cut_size_;
6214 }
6215 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_all_diff_cut_size() const {
6216  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_all_diff_cut_size)
6217  return _internal_max_all_diff_cut_size();
6218 }
6219 inline void SatParameters::_internal_set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
6220  _has_bits_[4] |= 0x00002000u;
6221  max_all_diff_cut_size_ = value;
6222 }
6223 inline void SatParameters::set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
6224  _internal_set_max_all_diff_cut_size(value);
6225  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_all_diff_cut_size)
6226 }
6227 
6228 // optional bool add_lin_max_cuts = 152 [default = true];
6229 inline bool SatParameters::_internal_has_add_lin_max_cuts() const {
6230  bool value = (_has_bits_[4] & 0x00080000u) != 0;
6231  return value;
6232 }
6233 inline bool SatParameters::has_add_lin_max_cuts() const {
6234  return _internal_has_add_lin_max_cuts();
6235 }
6236 inline void SatParameters::clear_add_lin_max_cuts() {
6237  add_lin_max_cuts_ = true;
6238  _has_bits_[4] &= ~0x00080000u;
6239 }
6240 inline bool SatParameters::_internal_add_lin_max_cuts() const {
6241  return add_lin_max_cuts_;
6242 }
6243 inline bool SatParameters::add_lin_max_cuts() const {
6244  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_lin_max_cuts)
6245  return _internal_add_lin_max_cuts();
6246 }
6247 inline void SatParameters::_internal_set_add_lin_max_cuts(bool value) {
6248  _has_bits_[4] |= 0x00080000u;
6249  add_lin_max_cuts_ = value;
6250 }
6251 inline void SatParameters::set_add_lin_max_cuts(bool value) {
6252  _internal_set_add_lin_max_cuts(value);
6253  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_lin_max_cuts)
6254 }
6255 
6256 // optional int32 max_integer_rounding_scaling = 119 [default = 600];
6257 inline bool SatParameters::_internal_has_max_integer_rounding_scaling() const {
6258  bool value = (_has_bits_[3] & 0x00400000u) != 0;
6259  return value;
6260 }
6261 inline bool SatParameters::has_max_integer_rounding_scaling() const {
6262  return _internal_has_max_integer_rounding_scaling();
6263 }
6264 inline void SatParameters::clear_max_integer_rounding_scaling() {
6265  max_integer_rounding_scaling_ = 600;
6266  _has_bits_[3] &= ~0x00400000u;
6267 }
6268 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_integer_rounding_scaling() const {
6269  return max_integer_rounding_scaling_;
6270 }
6271 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_integer_rounding_scaling() const {
6272  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_integer_rounding_scaling)
6273  return _internal_max_integer_rounding_scaling();
6274 }
6275 inline void SatParameters::_internal_set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value) {
6276  _has_bits_[3] |= 0x00400000u;
6277  max_integer_rounding_scaling_ = value;
6278 }
6279 inline void SatParameters::set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value) {
6280  _internal_set_max_integer_rounding_scaling(value);
6281  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_integer_rounding_scaling)
6282 }
6283 
6284 // optional bool add_lp_constraints_lazily = 112 [default = true];
6285 inline bool SatParameters::_internal_has_add_lp_constraints_lazily() const {
6286  bool value = (_has_bits_[4] & 0x00100000u) != 0;
6287  return value;
6288 }
6289 inline bool SatParameters::has_add_lp_constraints_lazily() const {
6290  return _internal_has_add_lp_constraints_lazily();
6291 }
6292 inline void SatParameters::clear_add_lp_constraints_lazily() {
6293  add_lp_constraints_lazily_ = true;
6294  _has_bits_[4] &= ~0x00100000u;
6295 }
6296 inline bool SatParameters::_internal_add_lp_constraints_lazily() const {
6297  return add_lp_constraints_lazily_;
6298 }
6299 inline bool SatParameters::add_lp_constraints_lazily() const {
6300  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.add_lp_constraints_lazily)
6301  return _internal_add_lp_constraints_lazily();
6302 }
6303 inline void SatParameters::_internal_set_add_lp_constraints_lazily(bool value) {
6304  _has_bits_[4] |= 0x00100000u;
6305  add_lp_constraints_lazily_ = value;
6306 }
6307 inline void SatParameters::set_add_lp_constraints_lazily(bool value) {
6308  _internal_set_add_lp_constraints_lazily(value);
6309  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.add_lp_constraints_lazily)
6310 }
6311 
6312 // optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
6313 inline bool SatParameters::_internal_has_min_orthogonality_for_lp_constraints() const {
6314  bool value = (_has_bits_[3] & 0x00800000u) != 0;
6315  return value;
6316 }
6317 inline bool SatParameters::has_min_orthogonality_for_lp_constraints() const {
6318  return _internal_has_min_orthogonality_for_lp_constraints();
6319 }
6320 inline void SatParameters::clear_min_orthogonality_for_lp_constraints() {
6321  min_orthogonality_for_lp_constraints_ = 0.05;
6322  _has_bits_[3] &= ~0x00800000u;
6323 }
6324 inline double SatParameters::_internal_min_orthogonality_for_lp_constraints() const {
6325  return min_orthogonality_for_lp_constraints_;
6326 }
6327 inline double SatParameters::min_orthogonality_for_lp_constraints() const {
6328  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
6329  return _internal_min_orthogonality_for_lp_constraints();
6330 }
6331 inline void SatParameters::_internal_set_min_orthogonality_for_lp_constraints(double value) {
6332  _has_bits_[3] |= 0x00800000u;
6333  min_orthogonality_for_lp_constraints_ = value;
6334 }
6335 inline void SatParameters::set_min_orthogonality_for_lp_constraints(double value) {
6336  _internal_set_min_orthogonality_for_lp_constraints(value);
6337  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.min_orthogonality_for_lp_constraints)
6338 }
6339 
6340 // optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
6341 inline bool SatParameters::_internal_has_max_cut_rounds_at_level_zero() const {
6342  bool value = (_has_bits_[4] & 0x00800000u) != 0;
6343  return value;
6344 }
6345 inline bool SatParameters::has_max_cut_rounds_at_level_zero() const {
6346  return _internal_has_max_cut_rounds_at_level_zero();
6347 }
6348 inline void SatParameters::clear_max_cut_rounds_at_level_zero() {
6349  max_cut_rounds_at_level_zero_ = 1;
6350  _has_bits_[4] &= ~0x00800000u;
6351 }
6352 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_cut_rounds_at_level_zero() const {
6353  return max_cut_rounds_at_level_zero_;
6354 }
6355 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_cut_rounds_at_level_zero() const {
6356  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_cut_rounds_at_level_zero)
6357  return _internal_max_cut_rounds_at_level_zero();
6358 }
6359 inline void SatParameters::_internal_set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value) {
6360  _has_bits_[4] |= 0x00800000u;
6361  max_cut_rounds_at_level_zero_ = value;
6362 }
6363 inline void SatParameters::set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value) {
6364  _internal_set_max_cut_rounds_at_level_zero(value);
6365  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_cut_rounds_at_level_zero)
6366 }
6367 
6368 // optional int32 max_consecutive_inactive_count = 121 [default = 100];
6369 inline bool SatParameters::_internal_has_max_consecutive_inactive_count() const {
6370  bool value = (_has_bits_[3] & 0x01000000u) != 0;
6371  return value;
6372 }
6373 inline bool SatParameters::has_max_consecutive_inactive_count() const {
6374  return _internal_has_max_consecutive_inactive_count();
6375 }
6376 inline void SatParameters::clear_max_consecutive_inactive_count() {
6377  max_consecutive_inactive_count_ = 100;
6378  _has_bits_[3] &= ~0x01000000u;
6379 }
6380 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_max_consecutive_inactive_count() const {
6381  return max_consecutive_inactive_count_;
6382 }
6383 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::max_consecutive_inactive_count() const {
6384  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.max_consecutive_inactive_count)
6385  return _internal_max_consecutive_inactive_count();
6386 }
6387 inline void SatParameters::_internal_set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
6388  _has_bits_[3] |= 0x01000000u;
6389  max_consecutive_inactive_count_ = value;
6390 }
6391 inline void SatParameters::set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value) {
6392  _internal_set_max_consecutive_inactive_count(value);
6393  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.max_consecutive_inactive_count)
6394 }
6395 
6396 // optional double cut_max_active_count_value = 155 [default = 10000000000];
6397 inline bool SatParameters::_internal_has_cut_max_active_count_value() const {
6398  bool value = (_has_bits_[4] & 0x00400000u) != 0;
6399  return value;
6400 }
6401 inline bool SatParameters::has_cut_max_active_count_value() const {
6402  return _internal_has_cut_max_active_count_value();
6403 }
6404 inline void SatParameters::clear_cut_max_active_count_value() {
6405  cut_max_active_count_value_ = 10000000000;
6406  _has_bits_[4] &= ~0x00400000u;
6407 }
6408 inline double SatParameters::_internal_cut_max_active_count_value() const {
6409  return cut_max_active_count_value_;
6410 }
6411 inline double SatParameters::cut_max_active_count_value() const {
6412  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_max_active_count_value)
6413  return _internal_cut_max_active_count_value();
6414 }
6415 inline void SatParameters::_internal_set_cut_max_active_count_value(double value) {
6416  _has_bits_[4] |= 0x00400000u;
6417  cut_max_active_count_value_ = value;
6418 }
6419 inline void SatParameters::set_cut_max_active_count_value(double value) {
6420  _internal_set_cut_max_active_count_value(value);
6421  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_max_active_count_value)
6422 }
6423 
6424 // optional double cut_active_count_decay = 156 [default = 0.8];
6425 inline bool SatParameters::_internal_has_cut_active_count_decay() const {
6426  bool value = (_has_bits_[4] & 0x10000000u) != 0;
6427  return value;
6428 }
6429 inline bool SatParameters::has_cut_active_count_decay() const {
6430  return _internal_has_cut_active_count_decay();
6431 }
6432 inline void SatParameters::clear_cut_active_count_decay() {
6433  cut_active_count_decay_ = 0.8;
6434  _has_bits_[4] &= ~0x10000000u;
6435 }
6436 inline double SatParameters::_internal_cut_active_count_decay() const {
6437  return cut_active_count_decay_;
6438 }
6439 inline double SatParameters::cut_active_count_decay() const {
6440  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_active_count_decay)
6441  return _internal_cut_active_count_decay();
6442 }
6443 inline void SatParameters::_internal_set_cut_active_count_decay(double value) {
6444  _has_bits_[4] |= 0x10000000u;
6445  cut_active_count_decay_ = value;
6446 }
6447 inline void SatParameters::set_cut_active_count_decay(double value) {
6448  _internal_set_cut_active_count_decay(value);
6449  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_active_count_decay)
6450 }
6451 
6452 // optional int32 cut_cleanup_target = 157 [default = 1000];
6453 inline bool SatParameters::_internal_has_cut_cleanup_target() const {
6454  bool value = (_has_bits_[4] & 0x20000000u) != 0;
6455  return value;
6456 }
6457 inline bool SatParameters::has_cut_cleanup_target() const {
6458  return _internal_has_cut_cleanup_target();
6459 }
6460 inline void SatParameters::clear_cut_cleanup_target() {
6461  cut_cleanup_target_ = 1000;
6462  _has_bits_[4] &= ~0x20000000u;
6463 }
6464 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_cut_cleanup_target() const {
6465  return cut_cleanup_target_;
6466 }
6467 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::cut_cleanup_target() const {
6468  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.cut_cleanup_target)
6469  return _internal_cut_cleanup_target();
6470 }
6471 inline void SatParameters::_internal_set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
6472  _has_bits_[4] |= 0x20000000u;
6473  cut_cleanup_target_ = value;
6474 }
6475 inline void SatParameters::set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value) {
6476  _internal_set_cut_cleanup_target(value);
6477  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.cut_cleanup_target)
6478 }
6479 
6480 // optional int32 new_constraints_batch_size = 122 [default = 50];
6481 inline bool SatParameters::_internal_has_new_constraints_batch_size() const {
6482  bool value = (_has_bits_[3] & 0x02000000u) != 0;
6483  return value;
6484 }
6485 inline bool SatParameters::has_new_constraints_batch_size() const {
6486  return _internal_has_new_constraints_batch_size();
6487 }
6488 inline void SatParameters::clear_new_constraints_batch_size() {
6489  new_constraints_batch_size_ = 50;
6490  _has_bits_[3] &= ~0x02000000u;
6491 }
6492 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_new_constraints_batch_size() const {
6493  return new_constraints_batch_size_;
6494 }
6495 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::new_constraints_batch_size() const {
6496  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.new_constraints_batch_size)
6497  return _internal_new_constraints_batch_size();
6498 }
6499 inline void SatParameters::_internal_set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
6500  _has_bits_[3] |= 0x02000000u;
6501  new_constraints_batch_size_ = value;
6502 }
6503 inline void SatParameters::set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
6504  _internal_set_new_constraints_batch_size(value);
6505  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.new_constraints_batch_size)
6506 }
6507 
6508 // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
6509 inline bool SatParameters::_internal_has_search_branching() const {
6510  bool value = (_has_bits_[0] & 0x00000400u) != 0;
6511  return value;
6512 }
6513 inline bool SatParameters::has_search_branching() const {
6514  return _internal_has_search_branching();
6515 }
6516 inline void SatParameters::clear_search_branching() {
6517  search_branching_ = 0;
6518  _has_bits_[0] &= ~0x00000400u;
6519 }
6520 inline ::operations_research::sat::SatParameters_SearchBranching SatParameters::_internal_search_branching() const {
6521  return static_cast< ::operations_research::sat::SatParameters_SearchBranching >(search_branching_);
6522 }
6523 inline ::operations_research::sat::SatParameters_SearchBranching SatParameters::search_branching() const {
6524  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.search_branching)
6525  return _internal_search_branching();
6526 }
6527 inline void SatParameters::_internal_set_search_branching(::operations_research::sat::SatParameters_SearchBranching value) {
6528  assert(::operations_research::sat::SatParameters_SearchBranching_IsValid(value));
6529  _has_bits_[0] |= 0x00000400u;
6530  search_branching_ = value;
6531 }
6532 inline void SatParameters::set_search_branching(::operations_research::sat::SatParameters_SearchBranching value) {
6533  _internal_set_search_branching(value);
6534  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.search_branching)
6535 }
6536 
6537 // optional int32 hint_conflict_limit = 153 [default = 10];
6538 inline bool SatParameters::_internal_has_hint_conflict_limit() const {
6539  bool value = (_has_bits_[4] & 0x00200000u) != 0;
6540  return value;
6541 }
6542 inline bool SatParameters::has_hint_conflict_limit() const {
6543  return _internal_has_hint_conflict_limit();
6544 }
6545 inline void SatParameters::clear_hint_conflict_limit() {
6546  hint_conflict_limit_ = 10;
6547  _has_bits_[4] &= ~0x00200000u;
6548 }
6549 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_hint_conflict_limit() const {
6550  return hint_conflict_limit_;
6551 }
6552 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::hint_conflict_limit() const {
6553  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.hint_conflict_limit)
6554  return _internal_hint_conflict_limit();
6555 }
6556 inline void SatParameters::_internal_set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value) {
6557  _has_bits_[4] |= 0x00200000u;
6558  hint_conflict_limit_ = value;
6559 }
6560 inline void SatParameters::set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value) {
6561  _internal_set_hint_conflict_limit(value);
6562  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.hint_conflict_limit)
6563 }
6564 
6565 // optional bool repair_hint = 167 [default = false];
6566 inline bool SatParameters::_internal_has_repair_hint() const {
6567  bool value = (_has_bits_[1] & 0x00200000u) != 0;
6568  return value;
6569 }
6570 inline bool SatParameters::has_repair_hint() const {
6571  return _internal_has_repair_hint();
6572 }
6573 inline void SatParameters::clear_repair_hint() {
6574  repair_hint_ = false;
6575  _has_bits_[1] &= ~0x00200000u;
6576 }
6577 inline bool SatParameters::_internal_repair_hint() const {
6578  return repair_hint_;
6579 }
6580 inline bool SatParameters::repair_hint() const {
6581  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.repair_hint)
6582  return _internal_repair_hint();
6583 }
6584 inline void SatParameters::_internal_set_repair_hint(bool value) {
6585  _has_bits_[1] |= 0x00200000u;
6586  repair_hint_ = value;
6587 }
6588 inline void SatParameters::set_repair_hint(bool value) {
6589  _internal_set_repair_hint(value);
6590  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.repair_hint)
6591 }
6592 
6593 // optional bool exploit_integer_lp_solution = 94 [default = true];
6594 inline bool SatParameters::_internal_has_exploit_integer_lp_solution() const {
6595  bool value = (_has_bits_[3] & 0x00040000u) != 0;
6596  return value;
6597 }
6598 inline bool SatParameters::has_exploit_integer_lp_solution() const {
6599  return _internal_has_exploit_integer_lp_solution();
6600 }
6601 inline void SatParameters::clear_exploit_integer_lp_solution() {
6602  exploit_integer_lp_solution_ = true;
6603  _has_bits_[3] &= ~0x00040000u;
6604 }
6605 inline bool SatParameters::_internal_exploit_integer_lp_solution() const {
6606  return exploit_integer_lp_solution_;
6607 }
6608 inline bool SatParameters::exploit_integer_lp_solution() const {
6609  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_integer_lp_solution)
6610  return _internal_exploit_integer_lp_solution();
6611 }
6612 inline void SatParameters::_internal_set_exploit_integer_lp_solution(bool value) {
6613  _has_bits_[3] |= 0x00040000u;
6614  exploit_integer_lp_solution_ = value;
6615 }
6616 inline void SatParameters::set_exploit_integer_lp_solution(bool value) {
6617  _internal_set_exploit_integer_lp_solution(value);
6618  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_integer_lp_solution)
6619 }
6620 
6621 // optional bool exploit_all_lp_solution = 116 [default = true];
6622 inline bool SatParameters::_internal_has_exploit_all_lp_solution() const {
6623  bool value = (_has_bits_[3] & 0x00080000u) != 0;
6624  return value;
6625 }
6626 inline bool SatParameters::has_exploit_all_lp_solution() const {
6627  return _internal_has_exploit_all_lp_solution();
6628 }
6629 inline void SatParameters::clear_exploit_all_lp_solution() {
6630  exploit_all_lp_solution_ = true;
6631  _has_bits_[3] &= ~0x00080000u;
6632 }
6633 inline bool SatParameters::_internal_exploit_all_lp_solution() const {
6634  return exploit_all_lp_solution_;
6635 }
6636 inline bool SatParameters::exploit_all_lp_solution() const {
6637  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_all_lp_solution)
6638  return _internal_exploit_all_lp_solution();
6639 }
6640 inline void SatParameters::_internal_set_exploit_all_lp_solution(bool value) {
6641  _has_bits_[3] |= 0x00080000u;
6642  exploit_all_lp_solution_ = value;
6643 }
6644 inline void SatParameters::set_exploit_all_lp_solution(bool value) {
6645  _internal_set_exploit_all_lp_solution(value);
6646  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_all_lp_solution)
6647 }
6648 
6649 // optional bool exploit_best_solution = 130 [default = false];
6650 inline bool SatParameters::_internal_has_exploit_best_solution() const {
6651  bool value = (_has_bits_[1] & 0x00400000u) != 0;
6652  return value;
6653 }
6654 inline bool SatParameters::has_exploit_best_solution() const {
6655  return _internal_has_exploit_best_solution();
6656 }
6657 inline void SatParameters::clear_exploit_best_solution() {
6658  exploit_best_solution_ = false;
6659  _has_bits_[1] &= ~0x00400000u;
6660 }
6661 inline bool SatParameters::_internal_exploit_best_solution() const {
6662  return exploit_best_solution_;
6663 }
6664 inline bool SatParameters::exploit_best_solution() const {
6665  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_best_solution)
6666  return _internal_exploit_best_solution();
6667 }
6668 inline void SatParameters::_internal_set_exploit_best_solution(bool value) {
6669  _has_bits_[1] |= 0x00400000u;
6670  exploit_best_solution_ = value;
6671 }
6672 inline void SatParameters::set_exploit_best_solution(bool value) {
6673  _internal_set_exploit_best_solution(value);
6674  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_best_solution)
6675 }
6676 
6677 // optional bool exploit_relaxation_solution = 161 [default = false];
6678 inline bool SatParameters::_internal_has_exploit_relaxation_solution() const {
6679  bool value = (_has_bits_[1] & 0x00800000u) != 0;
6680  return value;
6681 }
6682 inline bool SatParameters::has_exploit_relaxation_solution() const {
6683  return _internal_has_exploit_relaxation_solution();
6684 }
6685 inline void SatParameters::clear_exploit_relaxation_solution() {
6686  exploit_relaxation_solution_ = false;
6687  _has_bits_[1] &= ~0x00800000u;
6688 }
6689 inline bool SatParameters::_internal_exploit_relaxation_solution() const {
6690  return exploit_relaxation_solution_;
6691 }
6692 inline bool SatParameters::exploit_relaxation_solution() const {
6693  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_relaxation_solution)
6694  return _internal_exploit_relaxation_solution();
6695 }
6696 inline void SatParameters::_internal_set_exploit_relaxation_solution(bool value) {
6697  _has_bits_[1] |= 0x00800000u;
6698  exploit_relaxation_solution_ = value;
6699 }
6700 inline void SatParameters::set_exploit_relaxation_solution(bool value) {
6701  _internal_set_exploit_relaxation_solution(value);
6702  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_relaxation_solution)
6703 }
6704 
6705 // optional bool exploit_objective = 131 [default = true];
6706 inline bool SatParameters::_internal_has_exploit_objective() const {
6707  bool value = (_has_bits_[3] & 0x00100000u) != 0;
6708  return value;
6709 }
6710 inline bool SatParameters::has_exploit_objective() const {
6711  return _internal_has_exploit_objective();
6712 }
6713 inline void SatParameters::clear_exploit_objective() {
6714  exploit_objective_ = true;
6715  _has_bits_[3] &= ~0x00100000u;
6716 }
6717 inline bool SatParameters::_internal_exploit_objective() const {
6718  return exploit_objective_;
6719 }
6720 inline bool SatParameters::exploit_objective() const {
6721  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.exploit_objective)
6722  return _internal_exploit_objective();
6723 }
6724 inline void SatParameters::_internal_set_exploit_objective(bool value) {
6725  _has_bits_[3] |= 0x00100000u;
6726  exploit_objective_ = value;
6727 }
6728 inline void SatParameters::set_exploit_objective(bool value) {
6729  _internal_set_exploit_objective(value);
6730  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.exploit_objective)
6731 }
6732 
6733 // optional int64 probing_period_at_root = 142 [default = 0];
6734 inline bool SatParameters::_internal_has_probing_period_at_root() const {
6735  bool value = (_has_bits_[1] & 0x00002000u) != 0;
6736  return value;
6737 }
6738 inline bool SatParameters::has_probing_period_at_root() const {
6739  return _internal_has_probing_period_at_root();
6740 }
6741 inline void SatParameters::clear_probing_period_at_root() {
6742  probing_period_at_root_ = PROTOBUF_LONGLONG(0);
6743  _has_bits_[1] &= ~0x00002000u;
6744 }
6745 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_probing_period_at_root() const {
6746  return probing_period_at_root_;
6747 }
6748 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::probing_period_at_root() const {
6749  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.probing_period_at_root)
6750  return _internal_probing_period_at_root();
6751 }
6752 inline void SatParameters::_internal_set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value) {
6753  _has_bits_[1] |= 0x00002000u;
6754  probing_period_at_root_ = value;
6755 }
6756 inline void SatParameters::set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value) {
6757  _internal_set_probing_period_at_root(value);
6758  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.probing_period_at_root)
6759 }
6760 
6761 // optional bool use_probing_search = 176 [default = false];
6762 inline bool SatParameters::_internal_has_use_probing_search() const {
6763  bool value = (_has_bits_[1] & 0x01000000u) != 0;
6764  return value;
6765 }
6766 inline bool SatParameters::has_use_probing_search() const {
6767  return _internal_has_use_probing_search();
6768 }
6769 inline void SatParameters::clear_use_probing_search() {
6770  use_probing_search_ = false;
6771  _has_bits_[1] &= ~0x01000000u;
6772 }
6773 inline bool SatParameters::_internal_use_probing_search() const {
6774  return use_probing_search_;
6775 }
6776 inline bool SatParameters::use_probing_search() const {
6777  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_probing_search)
6778  return _internal_use_probing_search();
6779 }
6780 inline void SatParameters::_internal_set_use_probing_search(bool value) {
6781  _has_bits_[1] |= 0x01000000u;
6782  use_probing_search_ = value;
6783 }
6784 inline void SatParameters::set_use_probing_search(bool value) {
6785  _internal_set_use_probing_search(value);
6786  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_probing_search)
6787 }
6788 
6789 // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
6790 inline bool SatParameters::_internal_has_pseudo_cost_reliability_threshold() const {
6791  bool value = (_has_bits_[3] & 0x04000000u) != 0;
6792  return value;
6793 }
6794 inline bool SatParameters::has_pseudo_cost_reliability_threshold() const {
6795  return _internal_has_pseudo_cost_reliability_threshold();
6796 }
6797 inline void SatParameters::clear_pseudo_cost_reliability_threshold() {
6798  pseudo_cost_reliability_threshold_ = PROTOBUF_LONGLONG(100);
6799  _has_bits_[3] &= ~0x04000000u;
6800 }
6801 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_pseudo_cost_reliability_threshold() const {
6802  return pseudo_cost_reliability_threshold_;
6803 }
6804 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::pseudo_cost_reliability_threshold() const {
6805  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.pseudo_cost_reliability_threshold)
6806  return _internal_pseudo_cost_reliability_threshold();
6807 }
6808 inline void SatParameters::_internal_set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value) {
6809  _has_bits_[3] |= 0x04000000u;
6810  pseudo_cost_reliability_threshold_ = value;
6811 }
6812 inline void SatParameters::set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value) {
6813  _internal_set_pseudo_cost_reliability_threshold(value);
6814  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.pseudo_cost_reliability_threshold)
6815 }
6816 
6817 // optional bool optimize_with_core = 83 [default = false];
6818 inline bool SatParameters::_internal_has_optimize_with_core() const {
6819  bool value = (_has_bits_[0] & 0x02000000u) != 0;
6820  return value;
6821 }
6822 inline bool SatParameters::has_optimize_with_core() const {
6823  return _internal_has_optimize_with_core();
6824 }
6825 inline void SatParameters::clear_optimize_with_core() {
6826  optimize_with_core_ = false;
6827  _has_bits_[0] &= ~0x02000000u;
6828 }
6829 inline bool SatParameters::_internal_optimize_with_core() const {
6830  return optimize_with_core_;
6831 }
6832 inline bool SatParameters::optimize_with_core() const {
6833  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_core)
6834  return _internal_optimize_with_core();
6835 }
6836 inline void SatParameters::_internal_set_optimize_with_core(bool value) {
6837  _has_bits_[0] |= 0x02000000u;
6838  optimize_with_core_ = value;
6839 }
6840 inline void SatParameters::set_optimize_with_core(bool value) {
6841  _internal_set_optimize_with_core(value);
6842  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_core)
6843 }
6844 
6845 // optional int32 binary_search_num_conflicts = 99 [default = -1];
6846 inline bool SatParameters::_internal_has_binary_search_num_conflicts() const {
6847  bool value = (_has_bits_[3] & 0x00004000u) != 0;
6848  return value;
6849 }
6850 inline bool SatParameters::has_binary_search_num_conflicts() const {
6851  return _internal_has_binary_search_num_conflicts();
6852 }
6853 inline void SatParameters::clear_binary_search_num_conflicts() {
6854  binary_search_num_conflicts_ = -1;
6855  _has_bits_[3] &= ~0x00004000u;
6856 }
6857 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_binary_search_num_conflicts() const {
6858  return binary_search_num_conflicts_;
6859 }
6860 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::binary_search_num_conflicts() const {
6861  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.binary_search_num_conflicts)
6862  return _internal_binary_search_num_conflicts();
6863 }
6864 inline void SatParameters::_internal_set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value) {
6865  _has_bits_[3] |= 0x00004000u;
6866  binary_search_num_conflicts_ = value;
6867 }
6868 inline void SatParameters::set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value) {
6869  _internal_set_binary_search_num_conflicts(value);
6870  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.binary_search_num_conflicts)
6871 }
6872 
6873 // optional bool optimize_with_max_hs = 85 [default = false];
6874 inline bool SatParameters::_internal_has_optimize_with_max_hs() const {
6875  bool value = (_has_bits_[0] & 0x04000000u) != 0;
6876  return value;
6877 }
6878 inline bool SatParameters::has_optimize_with_max_hs() const {
6879  return _internal_has_optimize_with_max_hs();
6880 }
6881 inline void SatParameters::clear_optimize_with_max_hs() {
6882  optimize_with_max_hs_ = false;
6883  _has_bits_[0] &= ~0x04000000u;
6884 }
6885 inline bool SatParameters::_internal_optimize_with_max_hs() const {
6886  return optimize_with_max_hs_;
6887 }
6888 inline bool SatParameters::optimize_with_max_hs() const {
6889  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.optimize_with_max_hs)
6890  return _internal_optimize_with_max_hs();
6891 }
6892 inline void SatParameters::_internal_set_optimize_with_max_hs(bool value) {
6893  _has_bits_[0] |= 0x04000000u;
6894  optimize_with_max_hs_ = value;
6895 }
6896 inline void SatParameters::set_optimize_with_max_hs(bool value) {
6897  _internal_set_optimize_with_max_hs(value);
6898  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.optimize_with_max_hs)
6899 }
6900 
6901 // optional bool enumerate_all_solutions = 87 [default = false];
6902 inline bool SatParameters::_internal_has_enumerate_all_solutions() const {
6903  bool value = (_has_bits_[0] & 0x08000000u) != 0;
6904  return value;
6905 }
6906 inline bool SatParameters::has_enumerate_all_solutions() const {
6907  return _internal_has_enumerate_all_solutions();
6908 }
6909 inline void SatParameters::clear_enumerate_all_solutions() {
6910  enumerate_all_solutions_ = false;
6911  _has_bits_[0] &= ~0x08000000u;
6912 }
6913 inline bool SatParameters::_internal_enumerate_all_solutions() const {
6914  return enumerate_all_solutions_;
6915 }
6916 inline bool SatParameters::enumerate_all_solutions() const {
6917  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.enumerate_all_solutions)
6918  return _internal_enumerate_all_solutions();
6919 }
6920 inline void SatParameters::_internal_set_enumerate_all_solutions(bool value) {
6921  _has_bits_[0] |= 0x08000000u;
6922  enumerate_all_solutions_ = value;
6923 }
6924 inline void SatParameters::set_enumerate_all_solutions(bool value) {
6925  _internal_set_enumerate_all_solutions(value);
6926  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.enumerate_all_solutions)
6927 }
6928 
6929 // optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
6930 inline bool SatParameters::_internal_has_keep_all_feasible_solutions_in_presolve() const {
6931  bool value = (_has_bits_[0] & 0x10000000u) != 0;
6932  return value;
6933 }
6934 inline bool SatParameters::has_keep_all_feasible_solutions_in_presolve() const {
6935  return _internal_has_keep_all_feasible_solutions_in_presolve();
6936 }
6937 inline void SatParameters::clear_keep_all_feasible_solutions_in_presolve() {
6938  keep_all_feasible_solutions_in_presolve_ = false;
6939  _has_bits_[0] &= ~0x10000000u;
6940 }
6941 inline bool SatParameters::_internal_keep_all_feasible_solutions_in_presolve() const {
6942  return keep_all_feasible_solutions_in_presolve_;
6943 }
6944 inline bool SatParameters::keep_all_feasible_solutions_in_presolve() const {
6945  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.keep_all_feasible_solutions_in_presolve)
6946  return _internal_keep_all_feasible_solutions_in_presolve();
6947 }
6948 inline void SatParameters::_internal_set_keep_all_feasible_solutions_in_presolve(bool value) {
6949  _has_bits_[0] |= 0x10000000u;
6950  keep_all_feasible_solutions_in_presolve_ = value;
6951 }
6952 inline void SatParameters::set_keep_all_feasible_solutions_in_presolve(bool value) {
6953  _internal_set_keep_all_feasible_solutions_in_presolve(value);
6954  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.keep_all_feasible_solutions_in_presolve)
6955 }
6956 
6957 // optional bool fill_tightened_domains_in_response = 132 [default = false];
6958 inline bool SatParameters::_internal_has_fill_tightened_domains_in_response() const {
6959  bool value = (_has_bits_[1] & 0x00000020u) != 0;
6960  return value;
6961 }
6962 inline bool SatParameters::has_fill_tightened_domains_in_response() const {
6963  return _internal_has_fill_tightened_domains_in_response();
6964 }
6965 inline void SatParameters::clear_fill_tightened_domains_in_response() {
6966  fill_tightened_domains_in_response_ = false;
6967  _has_bits_[1] &= ~0x00000020u;
6968 }
6969 inline bool SatParameters::_internal_fill_tightened_domains_in_response() const {
6970  return fill_tightened_domains_in_response_;
6971 }
6972 inline bool SatParameters::fill_tightened_domains_in_response() const {
6973  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fill_tightened_domains_in_response)
6974  return _internal_fill_tightened_domains_in_response();
6975 }
6976 inline void SatParameters::_internal_set_fill_tightened_domains_in_response(bool value) {
6977  _has_bits_[1] |= 0x00000020u;
6978  fill_tightened_domains_in_response_ = value;
6979 }
6980 inline void SatParameters::set_fill_tightened_domains_in_response(bool value) {
6981  _internal_set_fill_tightened_domains_in_response(value);
6982  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fill_tightened_domains_in_response)
6983 }
6984 
6985 // optional bool instantiate_all_variables = 106 [default = true];
6986 inline bool SatParameters::_internal_has_instantiate_all_variables() const {
6987  bool value = (_has_bits_[3] & 0x00200000u) != 0;
6988  return value;
6989 }
6990 inline bool SatParameters::has_instantiate_all_variables() const {
6991  return _internal_has_instantiate_all_variables();
6992 }
6993 inline void SatParameters::clear_instantiate_all_variables() {
6994  instantiate_all_variables_ = true;
6995  _has_bits_[3] &= ~0x00200000u;
6996 }
6997 inline bool SatParameters::_internal_instantiate_all_variables() const {
6998  return instantiate_all_variables_;
6999 }
7000 inline bool SatParameters::instantiate_all_variables() const {
7001  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.instantiate_all_variables)
7002  return _internal_instantiate_all_variables();
7003 }
7004 inline void SatParameters::_internal_set_instantiate_all_variables(bool value) {
7005  _has_bits_[3] |= 0x00200000u;
7006  instantiate_all_variables_ = value;
7007 }
7008 inline void SatParameters::set_instantiate_all_variables(bool value) {
7009  _internal_set_instantiate_all_variables(value);
7010  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.instantiate_all_variables)
7011 }
7012 
7013 // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
7014 inline bool SatParameters::_internal_has_auto_detect_greater_than_at_least_one_of() const {
7015  bool value = (_has_bits_[3] & 0x40000000u) != 0;
7016  return value;
7017 }
7018 inline bool SatParameters::has_auto_detect_greater_than_at_least_one_of() const {
7019  return _internal_has_auto_detect_greater_than_at_least_one_of();
7020 }
7021 inline void SatParameters::clear_auto_detect_greater_than_at_least_one_of() {
7022  auto_detect_greater_than_at_least_one_of_ = true;
7023  _has_bits_[3] &= ~0x40000000u;
7024 }
7025 inline bool SatParameters::_internal_auto_detect_greater_than_at_least_one_of() const {
7026  return auto_detect_greater_than_at_least_one_of_;
7027 }
7028 inline bool SatParameters::auto_detect_greater_than_at_least_one_of() const {
7029  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.auto_detect_greater_than_at_least_one_of)
7030  return _internal_auto_detect_greater_than_at_least_one_of();
7031 }
7032 inline void SatParameters::_internal_set_auto_detect_greater_than_at_least_one_of(bool value) {
7033  _has_bits_[3] |= 0x40000000u;
7034  auto_detect_greater_than_at_least_one_of_ = value;
7035 }
7036 inline void SatParameters::set_auto_detect_greater_than_at_least_one_of(bool value) {
7037  _internal_set_auto_detect_greater_than_at_least_one_of(value);
7038  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.auto_detect_greater_than_at_least_one_of)
7039 }
7040 
7041 // optional bool stop_after_first_solution = 98 [default = false];
7042 inline bool SatParameters::_internal_has_stop_after_first_solution() const {
7043  bool value = (_has_bits_[1] & 0x00000040u) != 0;
7044  return value;
7045 }
7046 inline bool SatParameters::has_stop_after_first_solution() const {
7047  return _internal_has_stop_after_first_solution();
7048 }
7049 inline void SatParameters::clear_stop_after_first_solution() {
7050  stop_after_first_solution_ = false;
7051  _has_bits_[1] &= ~0x00000040u;
7052 }
7053 inline bool SatParameters::_internal_stop_after_first_solution() const {
7054  return stop_after_first_solution_;
7055 }
7056 inline bool SatParameters::stop_after_first_solution() const {
7057  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.stop_after_first_solution)
7058  return _internal_stop_after_first_solution();
7059 }
7060 inline void SatParameters::_internal_set_stop_after_first_solution(bool value) {
7061  _has_bits_[1] |= 0x00000040u;
7062  stop_after_first_solution_ = value;
7063 }
7064 inline void SatParameters::set_stop_after_first_solution(bool value) {
7065  _internal_set_stop_after_first_solution(value);
7066  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_first_solution)
7067 }
7068 
7069 // optional bool stop_after_presolve = 149 [default = false];
7070 inline bool SatParameters::_internal_has_stop_after_presolve() const {
7071  bool value = (_has_bits_[1] & 0x00000080u) != 0;
7072  return value;
7073 }
7074 inline bool SatParameters::has_stop_after_presolve() const {
7075  return _internal_has_stop_after_presolve();
7076 }
7077 inline void SatParameters::clear_stop_after_presolve() {
7078  stop_after_presolve_ = false;
7079  _has_bits_[1] &= ~0x00000080u;
7080 }
7081 inline bool SatParameters::_internal_stop_after_presolve() const {
7082  return stop_after_presolve_;
7083 }
7084 inline bool SatParameters::stop_after_presolve() const {
7085  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.stop_after_presolve)
7086  return _internal_stop_after_presolve();
7087 }
7088 inline void SatParameters::_internal_set_stop_after_presolve(bool value) {
7089  _has_bits_[1] |= 0x00000080u;
7090  stop_after_presolve_ = value;
7091 }
7092 inline void SatParameters::set_stop_after_presolve(bool value) {
7093  _internal_set_stop_after_presolve(value);
7094  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.stop_after_presolve)
7095 }
7096 
7097 // optional int32 num_search_workers = 100 [default = 1];
7098 inline bool SatParameters::_internal_has_num_search_workers() const {
7099  bool value = (_has_bits_[3] & 0x00008000u) != 0;
7100  return value;
7101 }
7102 inline bool SatParameters::has_num_search_workers() const {
7103  return _internal_has_num_search_workers();
7104 }
7105 inline void SatParameters::clear_num_search_workers() {
7106  num_search_workers_ = 1;
7107  _has_bits_[3] &= ~0x00008000u;
7108 }
7109 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_num_search_workers() const {
7110  return num_search_workers_;
7111 }
7112 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::num_search_workers() const {
7113  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.num_search_workers)
7114  return _internal_num_search_workers();
7115 }
7116 inline void SatParameters::_internal_set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
7117  _has_bits_[3] |= 0x00008000u;
7118  num_search_workers_ = value;
7119 }
7120 inline void SatParameters::set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value) {
7121  _internal_set_num_search_workers(value);
7122  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.num_search_workers)
7123 }
7124 
7125 // optional bool interleave_search = 136 [default = false];
7126 inline bool SatParameters::_internal_has_interleave_search() const {
7127  bool value = (_has_bits_[1] & 0x00000100u) != 0;
7128  return value;
7129 }
7130 inline bool SatParameters::has_interleave_search() const {
7131  return _internal_has_interleave_search();
7132 }
7133 inline void SatParameters::clear_interleave_search() {
7134  interleave_search_ = false;
7135  _has_bits_[1] &= ~0x00000100u;
7136 }
7137 inline bool SatParameters::_internal_interleave_search() const {
7138  return interleave_search_;
7139 }
7140 inline bool SatParameters::interleave_search() const {
7141  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.interleave_search)
7142  return _internal_interleave_search();
7143 }
7144 inline void SatParameters::_internal_set_interleave_search(bool value) {
7145  _has_bits_[1] |= 0x00000100u;
7146  interleave_search_ = value;
7147 }
7148 inline void SatParameters::set_interleave_search(bool value) {
7149  _internal_set_interleave_search(value);
7150  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_search)
7151 }
7152 
7153 // optional int32 interleave_batch_size = 134 [default = 1];
7154 inline bool SatParameters::_internal_has_interleave_batch_size() const {
7155  bool value = (_has_bits_[4] & 0x00000100u) != 0;
7156  return value;
7157 }
7158 inline bool SatParameters::has_interleave_batch_size() const {
7159  return _internal_has_interleave_batch_size();
7160 }
7161 inline void SatParameters::clear_interleave_batch_size() {
7162  interleave_batch_size_ = 1;
7163  _has_bits_[4] &= ~0x00000100u;
7164 }
7165 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_interleave_batch_size() const {
7166  return interleave_batch_size_;
7167 }
7168 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::interleave_batch_size() const {
7169  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.interleave_batch_size)
7170  return _internal_interleave_batch_size();
7171 }
7172 inline void SatParameters::_internal_set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
7173  _has_bits_[4] |= 0x00000100u;
7174  interleave_batch_size_ = value;
7175 }
7176 inline void SatParameters::set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
7177  _internal_set_interleave_batch_size(value);
7178  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.interleave_batch_size)
7179 }
7180 
7181 // optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
7182 inline bool SatParameters::_internal_has_reduce_memory_usage_in_interleave_mode() const {
7183  bool value = (_has_bits_[0] & 0x20000000u) != 0;
7184  return value;
7185 }
7186 inline bool SatParameters::has_reduce_memory_usage_in_interleave_mode() const {
7187  return _internal_has_reduce_memory_usage_in_interleave_mode();
7188 }
7189 inline void SatParameters::clear_reduce_memory_usage_in_interleave_mode() {
7190  reduce_memory_usage_in_interleave_mode_ = false;
7191  _has_bits_[0] &= ~0x20000000u;
7192 }
7193 inline bool SatParameters::_internal_reduce_memory_usage_in_interleave_mode() const {
7194  return reduce_memory_usage_in_interleave_mode_;
7195 }
7196 inline bool SatParameters::reduce_memory_usage_in_interleave_mode() const {
7197  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.reduce_memory_usage_in_interleave_mode)
7198  return _internal_reduce_memory_usage_in_interleave_mode();
7199 }
7200 inline void SatParameters::_internal_set_reduce_memory_usage_in_interleave_mode(bool value) {
7201  _has_bits_[0] |= 0x20000000u;
7202  reduce_memory_usage_in_interleave_mode_ = value;
7203 }
7204 inline void SatParameters::set_reduce_memory_usage_in_interleave_mode(bool value) {
7205  _internal_set_reduce_memory_usage_in_interleave_mode(value);
7206  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.reduce_memory_usage_in_interleave_mode)
7207 }
7208 
7209 // optional bool share_objective_bounds = 113 [default = true];
7210 inline bool SatParameters::_internal_has_share_objective_bounds() const {
7211  bool value = (_has_bits_[3] & 0x80000000u) != 0;
7212  return value;
7213 }
7214 inline bool SatParameters::has_share_objective_bounds() const {
7215  return _internal_has_share_objective_bounds();
7216 }
7217 inline void SatParameters::clear_share_objective_bounds() {
7218  share_objective_bounds_ = true;
7219  _has_bits_[3] &= ~0x80000000u;
7220 }
7221 inline bool SatParameters::_internal_share_objective_bounds() const {
7222  return share_objective_bounds_;
7223 }
7224 inline bool SatParameters::share_objective_bounds() const {
7225  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_objective_bounds)
7226  return _internal_share_objective_bounds();
7227 }
7228 inline void SatParameters::_internal_set_share_objective_bounds(bool value) {
7229  _has_bits_[3] |= 0x80000000u;
7230  share_objective_bounds_ = value;
7231 }
7232 inline void SatParameters::set_share_objective_bounds(bool value) {
7233  _internal_set_share_objective_bounds(value);
7234  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_objective_bounds)
7235 }
7236 
7237 // optional bool share_level_zero_bounds = 114 [default = true];
7238 inline bool SatParameters::_internal_has_share_level_zero_bounds() const {
7239  bool value = (_has_bits_[4] & 0x00000001u) != 0;
7240  return value;
7241 }
7242 inline bool SatParameters::has_share_level_zero_bounds() const {
7243  return _internal_has_share_level_zero_bounds();
7244 }
7245 inline void SatParameters::clear_share_level_zero_bounds() {
7246  share_level_zero_bounds_ = true;
7247  _has_bits_[4] &= ~0x00000001u;
7248 }
7249 inline bool SatParameters::_internal_share_level_zero_bounds() const {
7250  return share_level_zero_bounds_;
7251 }
7252 inline bool SatParameters::share_level_zero_bounds() const {
7253  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.share_level_zero_bounds)
7254  return _internal_share_level_zero_bounds();
7255 }
7256 inline void SatParameters::_internal_set_share_level_zero_bounds(bool value) {
7257  _has_bits_[4] |= 0x00000001u;
7258  share_level_zero_bounds_ = value;
7259 }
7260 inline void SatParameters::set_share_level_zero_bounds(bool value) {
7261  _internal_set_share_level_zero_bounds(value);
7262  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.share_level_zero_bounds)
7263 }
7264 
7265 // optional bool use_lns_only = 101 [default = false];
7266 inline bool SatParameters::_internal_has_use_lns_only() const {
7267  bool value = (_has_bits_[0] & 0x40000000u) != 0;
7268  return value;
7269 }
7270 inline bool SatParameters::has_use_lns_only() const {
7271  return _internal_has_use_lns_only();
7272 }
7273 inline void SatParameters::clear_use_lns_only() {
7274  use_lns_only_ = false;
7275  _has_bits_[0] &= ~0x40000000u;
7276 }
7277 inline bool SatParameters::_internal_use_lns_only() const {
7278  return use_lns_only_;
7279 }
7280 inline bool SatParameters::use_lns_only() const {
7281  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_lns_only)
7282  return _internal_use_lns_only();
7283 }
7284 inline void SatParameters::_internal_set_use_lns_only(bool value) {
7285  _has_bits_[0] |= 0x40000000u;
7286  use_lns_only_ = value;
7287 }
7288 inline void SatParameters::set_use_lns_only(bool value) {
7289  _internal_set_use_lns_only(value);
7290  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_lns_only)
7291 }
7292 
7293 // optional bool lns_focus_on_decision_variables = 105 [default = false];
7294 inline bool SatParameters::_internal_has_lns_focus_on_decision_variables() const {
7295  bool value = (_has_bits_[0] & 0x80000000u) != 0;
7296  return value;
7297 }
7298 inline bool SatParameters::has_lns_focus_on_decision_variables() const {
7299  return _internal_has_lns_focus_on_decision_variables();
7300 }
7301 inline void SatParameters::clear_lns_focus_on_decision_variables() {
7302  lns_focus_on_decision_variables_ = false;
7303  _has_bits_[0] &= ~0x80000000u;
7304 }
7305 inline bool SatParameters::_internal_lns_focus_on_decision_variables() const {
7306  return lns_focus_on_decision_variables_;
7307 }
7308 inline bool SatParameters::lns_focus_on_decision_variables() const {
7309  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lns_focus_on_decision_variables)
7310  return _internal_lns_focus_on_decision_variables();
7311 }
7312 inline void SatParameters::_internal_set_lns_focus_on_decision_variables(bool value) {
7313  _has_bits_[0] |= 0x80000000u;
7314  lns_focus_on_decision_variables_ = value;
7315 }
7316 inline void SatParameters::set_lns_focus_on_decision_variables(bool value) {
7317  _internal_set_lns_focus_on_decision_variables(value);
7318  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lns_focus_on_decision_variables)
7319 }
7320 
7321 // optional bool lns_expand_intervals_in_constraint_graph = 184 [default = true];
7322 inline bool SatParameters::_internal_has_lns_expand_intervals_in_constraint_graph() const {
7323  bool value = (_has_bits_[4] & 0x00000002u) != 0;
7324  return value;
7325 }
7326 inline bool SatParameters::has_lns_expand_intervals_in_constraint_graph() const {
7327  return _internal_has_lns_expand_intervals_in_constraint_graph();
7328 }
7329 inline void SatParameters::clear_lns_expand_intervals_in_constraint_graph() {
7330  lns_expand_intervals_in_constraint_graph_ = true;
7331  _has_bits_[4] &= ~0x00000002u;
7332 }
7333 inline bool SatParameters::_internal_lns_expand_intervals_in_constraint_graph() const {
7334  return lns_expand_intervals_in_constraint_graph_;
7335 }
7336 inline bool SatParameters::lns_expand_intervals_in_constraint_graph() const {
7337  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.lns_expand_intervals_in_constraint_graph)
7338  return _internal_lns_expand_intervals_in_constraint_graph();
7339 }
7340 inline void SatParameters::_internal_set_lns_expand_intervals_in_constraint_graph(bool value) {
7341  _has_bits_[4] |= 0x00000002u;
7342  lns_expand_intervals_in_constraint_graph_ = value;
7343 }
7344 inline void SatParameters::set_lns_expand_intervals_in_constraint_graph(bool value) {
7345  _internal_set_lns_expand_intervals_in_constraint_graph(value);
7346  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.lns_expand_intervals_in_constraint_graph)
7347 }
7348 
7349 // optional bool use_rins_lns = 129 [default = true];
7350 inline bool SatParameters::_internal_has_use_rins_lns() const {
7351  bool value = (_has_bits_[4] & 0x00000010u) != 0;
7352  return value;
7353 }
7354 inline bool SatParameters::has_use_rins_lns() const {
7355  return _internal_has_use_rins_lns();
7356 }
7357 inline void SatParameters::clear_use_rins_lns() {
7358  use_rins_lns_ = true;
7359  _has_bits_[4] &= ~0x00000010u;
7360 }
7361 inline bool SatParameters::_internal_use_rins_lns() const {
7362  return use_rins_lns_;
7363 }
7364 inline bool SatParameters::use_rins_lns() const {
7365  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_rins_lns)
7366  return _internal_use_rins_lns();
7367 }
7368 inline void SatParameters::_internal_set_use_rins_lns(bool value) {
7369  _has_bits_[4] |= 0x00000010u;
7370  use_rins_lns_ = value;
7371 }
7372 inline void SatParameters::set_use_rins_lns(bool value) {
7373  _internal_set_use_rins_lns(value);
7374  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_rins_lns)
7375 }
7376 
7377 // optional bool use_feasibility_pump = 164 [default = true];
7378 inline bool SatParameters::_internal_has_use_feasibility_pump() const {
7379  bool value = (_has_bits_[4] & 0x00000020u) != 0;
7380  return value;
7381 }
7382 inline bool SatParameters::has_use_feasibility_pump() const {
7383  return _internal_has_use_feasibility_pump();
7384 }
7385 inline void SatParameters::clear_use_feasibility_pump() {
7386  use_feasibility_pump_ = true;
7387  _has_bits_[4] &= ~0x00000020u;
7388 }
7389 inline bool SatParameters::_internal_use_feasibility_pump() const {
7390  return use_feasibility_pump_;
7391 }
7392 inline bool SatParameters::use_feasibility_pump() const {
7393  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_feasibility_pump)
7394  return _internal_use_feasibility_pump();
7395 }
7396 inline void SatParameters::_internal_set_use_feasibility_pump(bool value) {
7397  _has_bits_[4] |= 0x00000020u;
7398  use_feasibility_pump_ = value;
7399 }
7400 inline void SatParameters::set_use_feasibility_pump(bool value) {
7401  _internal_set_use_feasibility_pump(value);
7402  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_feasibility_pump)
7403 }
7404 
7405 // optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
7406 inline bool SatParameters::_internal_has_fp_rounding() const {
7407  bool value = (_has_bits_[4] & 0x40000000u) != 0;
7408  return value;
7409 }
7410 inline bool SatParameters::has_fp_rounding() const {
7411  return _internal_has_fp_rounding();
7412 }
7413 inline void SatParameters::clear_fp_rounding() {
7414  fp_rounding_ = 2;
7415  _has_bits_[4] &= ~0x40000000u;
7416 }
7417 inline ::operations_research::sat::SatParameters_FPRoundingMethod SatParameters::_internal_fp_rounding() const {
7418  return static_cast< ::operations_research::sat::SatParameters_FPRoundingMethod >(fp_rounding_);
7419 }
7420 inline ::operations_research::sat::SatParameters_FPRoundingMethod SatParameters::fp_rounding() const {
7421  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.fp_rounding)
7422  return _internal_fp_rounding();
7423 }
7424 inline void SatParameters::_internal_set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value) {
7425  assert(::operations_research::sat::SatParameters_FPRoundingMethod_IsValid(value));
7426  _has_bits_[4] |= 0x40000000u;
7427  fp_rounding_ = value;
7428 }
7429 inline void SatParameters::set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value) {
7430  _internal_set_fp_rounding(value);
7431  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.fp_rounding)
7432 }
7433 
7434 // optional bool use_relaxation_lns = 150 [default = false];
7435 inline bool SatParameters::_internal_has_use_relaxation_lns() const {
7436  bool value = (_has_bits_[1] & 0x00000001u) != 0;
7437  return value;
7438 }
7439 inline bool SatParameters::has_use_relaxation_lns() const {
7440  return _internal_has_use_relaxation_lns();
7441 }
7442 inline void SatParameters::clear_use_relaxation_lns() {
7443  use_relaxation_lns_ = false;
7444  _has_bits_[1] &= ~0x00000001u;
7445 }
7446 inline bool SatParameters::_internal_use_relaxation_lns() const {
7447  return use_relaxation_lns_;
7448 }
7449 inline bool SatParameters::use_relaxation_lns() const {
7450  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_relaxation_lns)
7451  return _internal_use_relaxation_lns();
7452 }
7453 inline void SatParameters::_internal_set_use_relaxation_lns(bool value) {
7454  _has_bits_[1] |= 0x00000001u;
7455  use_relaxation_lns_ = value;
7456 }
7457 inline void SatParameters::set_use_relaxation_lns(bool value) {
7458  _internal_set_use_relaxation_lns(value);
7459  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_relaxation_lns)
7460 }
7461 
7462 // optional bool diversify_lns_params = 137 [default = false];
7463 inline bool SatParameters::_internal_has_diversify_lns_params() const {
7464  bool value = (_has_bits_[1] & 0x00000002u) != 0;
7465  return value;
7466 }
7467 inline bool SatParameters::has_diversify_lns_params() const {
7468  return _internal_has_diversify_lns_params();
7469 }
7470 inline void SatParameters::clear_diversify_lns_params() {
7471  diversify_lns_params_ = false;
7472  _has_bits_[1] &= ~0x00000002u;
7473 }
7474 inline bool SatParameters::_internal_diversify_lns_params() const {
7475  return diversify_lns_params_;
7476 }
7477 inline bool SatParameters::diversify_lns_params() const {
7478  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.diversify_lns_params)
7479  return _internal_diversify_lns_params();
7480 }
7481 inline void SatParameters::_internal_set_diversify_lns_params(bool value) {
7482  _has_bits_[1] |= 0x00000002u;
7483  diversify_lns_params_ = value;
7484 }
7485 inline void SatParameters::set_diversify_lns_params(bool value) {
7486  _internal_set_diversify_lns_params(value);
7487  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.diversify_lns_params)
7488 }
7489 
7490 // optional bool randomize_search = 103 [default = false];
7491 inline bool SatParameters::_internal_has_randomize_search() const {
7492  bool value = (_has_bits_[1] & 0x00000004u) != 0;
7493  return value;
7494 }
7495 inline bool SatParameters::has_randomize_search() const {
7496  return _internal_has_randomize_search();
7497 }
7498 inline void SatParameters::clear_randomize_search() {
7499  randomize_search_ = false;
7500  _has_bits_[1] &= ~0x00000004u;
7501 }
7502 inline bool SatParameters::_internal_randomize_search() const {
7503  return randomize_search_;
7504 }
7505 inline bool SatParameters::randomize_search() const {
7506  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.randomize_search)
7507  return _internal_randomize_search();
7508 }
7509 inline void SatParameters::_internal_set_randomize_search(bool value) {
7510  _has_bits_[1] |= 0x00000004u;
7511  randomize_search_ = value;
7512 }
7513 inline void SatParameters::set_randomize_search(bool value) {
7514  _internal_set_randomize_search(value);
7515  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.randomize_search)
7516 }
7517 
7518 // optional int64 search_randomization_tolerance = 104 [default = 0];
7519 inline bool SatParameters::_internal_has_search_randomization_tolerance() const {
7520  bool value = (_has_bits_[0] & 0x00100000u) != 0;
7521  return value;
7522 }
7523 inline bool SatParameters::has_search_randomization_tolerance() const {
7524  return _internal_has_search_randomization_tolerance();
7525 }
7526 inline void SatParameters::clear_search_randomization_tolerance() {
7527  search_randomization_tolerance_ = PROTOBUF_LONGLONG(0);
7528  _has_bits_[0] &= ~0x00100000u;
7529 }
7530 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::_internal_search_randomization_tolerance() const {
7531  return search_randomization_tolerance_;
7532 }
7533 inline ::PROTOBUF_NAMESPACE_ID::int64 SatParameters::search_randomization_tolerance() const {
7534  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.search_randomization_tolerance)
7535  return _internal_search_randomization_tolerance();
7536 }
7537 inline void SatParameters::_internal_set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value) {
7538  _has_bits_[0] |= 0x00100000u;
7539  search_randomization_tolerance_ = value;
7540 }
7541 inline void SatParameters::set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value) {
7542  _internal_set_search_randomization_tolerance(value);
7543  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.search_randomization_tolerance)
7544 }
7545 
7546 // optional bool use_optional_variables = 108 [default = true];
7547 inline bool SatParameters::_internal_has_use_optional_variables() const {
7548  bool value = (_has_bits_[4] & 0x00000040u) != 0;
7549  return value;
7550 }
7551 inline bool SatParameters::has_use_optional_variables() const {
7552  return _internal_has_use_optional_variables();
7553 }
7554 inline void SatParameters::clear_use_optional_variables() {
7555  use_optional_variables_ = true;
7556  _has_bits_[4] &= ~0x00000040u;
7557 }
7558 inline bool SatParameters::_internal_use_optional_variables() const {
7559  return use_optional_variables_;
7560 }
7561 inline bool SatParameters::use_optional_variables() const {
7562  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_optional_variables)
7563  return _internal_use_optional_variables();
7564 }
7565 inline void SatParameters::_internal_set_use_optional_variables(bool value) {
7566  _has_bits_[4] |= 0x00000040u;
7567  use_optional_variables_ = value;
7568 }
7569 inline void SatParameters::set_use_optional_variables(bool value) {
7570  _internal_set_use_optional_variables(value);
7571  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_optional_variables)
7572 }
7573 
7574 // optional bool use_exact_lp_reason = 109 [default = true];
7575 inline bool SatParameters::_internal_has_use_exact_lp_reason() const {
7576  bool value = (_has_bits_[4] & 0x00000080u) != 0;
7577  return value;
7578 }
7579 inline bool SatParameters::has_use_exact_lp_reason() const {
7580  return _internal_has_use_exact_lp_reason();
7581 }
7582 inline void SatParameters::clear_use_exact_lp_reason() {
7583  use_exact_lp_reason_ = true;
7584  _has_bits_[4] &= ~0x00000080u;
7585 }
7586 inline bool SatParameters::_internal_use_exact_lp_reason() const {
7587  return use_exact_lp_reason_;
7588 }
7589 inline bool SatParameters::use_exact_lp_reason() const {
7590  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_exact_lp_reason)
7591  return _internal_use_exact_lp_reason();
7592 }
7593 inline void SatParameters::_internal_set_use_exact_lp_reason(bool value) {
7594  _has_bits_[4] |= 0x00000080u;
7595  use_exact_lp_reason_ = value;
7596 }
7597 inline void SatParameters::set_use_exact_lp_reason(bool value) {
7598  _internal_set_use_exact_lp_reason(value);
7599  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_exact_lp_reason)
7600 }
7601 
7602 // optional bool use_branching_in_lp = 139 [default = false];
7603 inline bool SatParameters::_internal_has_use_branching_in_lp() const {
7604  bool value = (_has_bits_[1] & 0x00000008u) != 0;
7605  return value;
7606 }
7607 inline bool SatParameters::has_use_branching_in_lp() const {
7608  return _internal_has_use_branching_in_lp();
7609 }
7610 inline void SatParameters::clear_use_branching_in_lp() {
7611  use_branching_in_lp_ = false;
7612  _has_bits_[1] &= ~0x00000008u;
7613 }
7614 inline bool SatParameters::_internal_use_branching_in_lp() const {
7615  return use_branching_in_lp_;
7616 }
7617 inline bool SatParameters::use_branching_in_lp() const {
7618  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_branching_in_lp)
7619  return _internal_use_branching_in_lp();
7620 }
7621 inline void SatParameters::_internal_set_use_branching_in_lp(bool value) {
7622  _has_bits_[1] |= 0x00000008u;
7623  use_branching_in_lp_ = value;
7624 }
7625 inline void SatParameters::set_use_branching_in_lp(bool value) {
7626  _internal_set_use_branching_in_lp(value);
7627  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_branching_in_lp)
7628 }
7629 
7630 // optional bool use_combined_no_overlap = 133 [default = false];
7631 inline bool SatParameters::_internal_has_use_combined_no_overlap() const {
7632  bool value = (_has_bits_[1] & 0x00000010u) != 0;
7633  return value;
7634 }
7635 inline bool SatParameters::has_use_combined_no_overlap() const {
7636  return _internal_has_use_combined_no_overlap();
7637 }
7638 inline void SatParameters::clear_use_combined_no_overlap() {
7639  use_combined_no_overlap_ = false;
7640  _has_bits_[1] &= ~0x00000010u;
7641 }
7642 inline bool SatParameters::_internal_use_combined_no_overlap() const {
7643  return use_combined_no_overlap_;
7644 }
7645 inline bool SatParameters::use_combined_no_overlap() const {
7646  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_combined_no_overlap)
7647  return _internal_use_combined_no_overlap();
7648 }
7649 inline void SatParameters::_internal_set_use_combined_no_overlap(bool value) {
7650  _has_bits_[1] |= 0x00000010u;
7651  use_combined_no_overlap_ = value;
7652 }
7653 inline void SatParameters::set_use_combined_no_overlap(bool value) {
7654  _internal_set_use_combined_no_overlap(value);
7655  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_combined_no_overlap)
7656 }
7657 
7658 // optional bool catch_sigint_signal = 135 [default = true];
7659 inline bool SatParameters::_internal_has_catch_sigint_signal() const {
7660  bool value = (_has_bits_[4] & 0x00004000u) != 0;
7661  return value;
7662 }
7663 inline bool SatParameters::has_catch_sigint_signal() const {
7664  return _internal_has_catch_sigint_signal();
7665 }
7666 inline void SatParameters::clear_catch_sigint_signal() {
7667  catch_sigint_signal_ = true;
7668  _has_bits_[4] &= ~0x00004000u;
7669 }
7670 inline bool SatParameters::_internal_catch_sigint_signal() const {
7671  return catch_sigint_signal_;
7672 }
7673 inline bool SatParameters::catch_sigint_signal() const {
7674  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.catch_sigint_signal)
7675  return _internal_catch_sigint_signal();
7676 }
7677 inline void SatParameters::_internal_set_catch_sigint_signal(bool value) {
7678  _has_bits_[4] |= 0x00004000u;
7679  catch_sigint_signal_ = value;
7680 }
7681 inline void SatParameters::set_catch_sigint_signal(bool value) {
7682  _internal_set_catch_sigint_signal(value);
7683  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.catch_sigint_signal)
7684 }
7685 
7686 // optional bool use_implied_bounds = 144 [default = true];
7687 inline bool SatParameters::_internal_has_use_implied_bounds() const {
7688  bool value = (_has_bits_[4] & 0x00008000u) != 0;
7689  return value;
7690 }
7691 inline bool SatParameters::has_use_implied_bounds() const {
7692  return _internal_has_use_implied_bounds();
7693 }
7694 inline void SatParameters::clear_use_implied_bounds() {
7695  use_implied_bounds_ = true;
7696  _has_bits_[4] &= ~0x00008000u;
7697 }
7698 inline bool SatParameters::_internal_use_implied_bounds() const {
7699  return use_implied_bounds_;
7700 }
7701 inline bool SatParameters::use_implied_bounds() const {
7702  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.use_implied_bounds)
7703  return _internal_use_implied_bounds();
7704 }
7705 inline void SatParameters::_internal_set_use_implied_bounds(bool value) {
7706  _has_bits_[4] |= 0x00008000u;
7707  use_implied_bounds_ = value;
7708 }
7709 inline void SatParameters::set_use_implied_bounds(bool value) {
7710  _internal_set_use_implied_bounds(value);
7711  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.use_implied_bounds)
7712 }
7713 
7714 // optional bool polish_lp_solution = 175 [default = false];
7715 inline bool SatParameters::_internal_has_polish_lp_solution() const {
7716  bool value = (_has_bits_[1] & 0x02000000u) != 0;
7717  return value;
7718 }
7719 inline bool SatParameters::has_polish_lp_solution() const {
7720  return _internal_has_polish_lp_solution();
7721 }
7722 inline void SatParameters::clear_polish_lp_solution() {
7723  polish_lp_solution_ = false;
7724  _has_bits_[1] &= ~0x02000000u;
7725 }
7726 inline bool SatParameters::_internal_polish_lp_solution() const {
7727  return polish_lp_solution_;
7728 }
7729 inline bool SatParameters::polish_lp_solution() const {
7730  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.polish_lp_solution)
7731  return _internal_polish_lp_solution();
7732 }
7733 inline void SatParameters::_internal_set_polish_lp_solution(bool value) {
7734  _has_bits_[1] |= 0x02000000u;
7735  polish_lp_solution_ = value;
7736 }
7737 inline void SatParameters::set_polish_lp_solution(bool value) {
7738  _internal_set_polish_lp_solution(value);
7739  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.polish_lp_solution)
7740 }
7741 
7742 // optional bool convert_intervals = 177 [default = false];
7743 inline bool SatParameters::_internal_has_convert_intervals() const {
7744  bool value = (_has_bits_[1] & 0x04000000u) != 0;
7745  return value;
7746 }
7747 inline bool SatParameters::has_convert_intervals() const {
7748  return _internal_has_convert_intervals();
7749 }
7750 inline void SatParameters::clear_convert_intervals() {
7751  convert_intervals_ = false;
7752  _has_bits_[1] &= ~0x04000000u;
7753 }
7754 inline bool SatParameters::_internal_convert_intervals() const {
7755  return convert_intervals_;
7756 }
7757 inline bool SatParameters::convert_intervals() const {
7758  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.convert_intervals)
7759  return _internal_convert_intervals();
7760 }
7761 inline void SatParameters::_internal_set_convert_intervals(bool value) {
7762  _has_bits_[1] |= 0x04000000u;
7763  convert_intervals_ = value;
7764 }
7765 inline void SatParameters::set_convert_intervals(bool value) {
7766  _internal_set_convert_intervals(value);
7767  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.convert_intervals)
7768 }
7769 
7770 // optional int32 symmetry_level = 183 [default = 2];
7771 inline bool SatParameters::_internal_has_symmetry_level() const {
7772  bool value = (_has_bits_[5] & 0x00000001u) != 0;
7773  return value;
7774 }
7775 inline bool SatParameters::has_symmetry_level() const {
7776  return _internal_has_symmetry_level();
7777 }
7778 inline void SatParameters::clear_symmetry_level() {
7779  symmetry_level_ = 2;
7780  _has_bits_[5] &= ~0x00000001u;
7781 }
7782 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_symmetry_level() const {
7783  return symmetry_level_;
7784 }
7785 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::symmetry_level() const {
7786  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.symmetry_level)
7787  return _internal_symmetry_level();
7788 }
7789 inline void SatParameters::_internal_set_symmetry_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
7790  _has_bits_[5] |= 0x00000001u;
7791  symmetry_level_ = value;
7792 }
7793 inline void SatParameters::set_symmetry_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
7794  _internal_set_symmetry_level(value);
7795  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.symmetry_level)
7796 }
7797 
7798 // optional double mip_max_bound = 124 [default = 10000000];
7799 inline bool SatParameters::_internal_has_mip_max_bound() const {
7800  bool value = (_has_bits_[3] & 0x08000000u) != 0;
7801  return value;
7802 }
7803 inline bool SatParameters::has_mip_max_bound() const {
7804  return _internal_has_mip_max_bound();
7805 }
7806 inline void SatParameters::clear_mip_max_bound() {
7807  mip_max_bound_ = 10000000;
7808  _has_bits_[3] &= ~0x08000000u;
7809 }
7810 inline double SatParameters::_internal_mip_max_bound() const {
7811  return mip_max_bound_;
7812 }
7813 inline double SatParameters::mip_max_bound() const {
7814  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_max_bound)
7815  return _internal_mip_max_bound();
7816 }
7817 inline void SatParameters::_internal_set_mip_max_bound(double value) {
7818  _has_bits_[3] |= 0x08000000u;
7819  mip_max_bound_ = value;
7820 }
7821 inline void SatParameters::set_mip_max_bound(double value) {
7822  _internal_set_mip_max_bound(value);
7823  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_bound)
7824 }
7825 
7826 // optional double mip_var_scaling = 125 [default = 1];
7827 inline bool SatParameters::_internal_has_mip_var_scaling() const {
7828  bool value = (_has_bits_[3] & 0x10000000u) != 0;
7829  return value;
7830 }
7831 inline bool SatParameters::has_mip_var_scaling() const {
7832  return _internal_has_mip_var_scaling();
7833 }
7834 inline void SatParameters::clear_mip_var_scaling() {
7835  mip_var_scaling_ = 1;
7836  _has_bits_[3] &= ~0x10000000u;
7837 }
7838 inline double SatParameters::_internal_mip_var_scaling() const {
7839  return mip_var_scaling_;
7840 }
7841 inline double SatParameters::mip_var_scaling() const {
7842  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_var_scaling)
7843  return _internal_mip_var_scaling();
7844 }
7845 inline void SatParameters::_internal_set_mip_var_scaling(double value) {
7846  _has_bits_[3] |= 0x10000000u;
7847  mip_var_scaling_ = value;
7848 }
7849 inline void SatParameters::set_mip_var_scaling(double value) {
7850  _internal_set_mip_var_scaling(value);
7851  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_var_scaling)
7852 }
7853 
7854 // optional bool mip_automatically_scale_variables = 166 [default = true];
7855 inline bool SatParameters::_internal_has_mip_automatically_scale_variables() const {
7856  bool value = (_has_bits_[4] & 0x00010000u) != 0;
7857  return value;
7858 }
7859 inline bool SatParameters::has_mip_automatically_scale_variables() const {
7860  return _internal_has_mip_automatically_scale_variables();
7861 }
7862 inline void SatParameters::clear_mip_automatically_scale_variables() {
7863  mip_automatically_scale_variables_ = true;
7864  _has_bits_[4] &= ~0x00010000u;
7865 }
7866 inline bool SatParameters::_internal_mip_automatically_scale_variables() const {
7867  return mip_automatically_scale_variables_;
7868 }
7869 inline bool SatParameters::mip_automatically_scale_variables() const {
7870  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_automatically_scale_variables)
7871  return _internal_mip_automatically_scale_variables();
7872 }
7873 inline void SatParameters::_internal_set_mip_automatically_scale_variables(bool value) {
7874  _has_bits_[4] |= 0x00010000u;
7875  mip_automatically_scale_variables_ = value;
7876 }
7877 inline void SatParameters::set_mip_automatically_scale_variables(bool value) {
7878  _internal_set_mip_automatically_scale_variables(value);
7879  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_automatically_scale_variables)
7880 }
7881 
7882 // optional double mip_wanted_precision = 126 [default = 1e-06];
7883 inline bool SatParameters::_internal_has_mip_wanted_precision() const {
7884  bool value = (_has_bits_[3] & 0x20000000u) != 0;
7885  return value;
7886 }
7887 inline bool SatParameters::has_mip_wanted_precision() const {
7888  return _internal_has_mip_wanted_precision();
7889 }
7890 inline void SatParameters::clear_mip_wanted_precision() {
7891  mip_wanted_precision_ = 1e-06;
7892  _has_bits_[3] &= ~0x20000000u;
7893 }
7894 inline double SatParameters::_internal_mip_wanted_precision() const {
7895  return mip_wanted_precision_;
7896 }
7897 inline double SatParameters::mip_wanted_precision() const {
7898  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_wanted_precision)
7899  return _internal_mip_wanted_precision();
7900 }
7901 inline void SatParameters::_internal_set_mip_wanted_precision(double value) {
7902  _has_bits_[3] |= 0x20000000u;
7903  mip_wanted_precision_ = value;
7904 }
7905 inline void SatParameters::set_mip_wanted_precision(double value) {
7906  _internal_set_mip_wanted_precision(value);
7907  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_wanted_precision)
7908 }
7909 
7910 // optional int32 mip_max_activity_exponent = 127 [default = 53];
7911 inline bool SatParameters::_internal_has_mip_max_activity_exponent() const {
7912  bool value = (_has_bits_[4] & 0x00000004u) != 0;
7913  return value;
7914 }
7915 inline bool SatParameters::has_mip_max_activity_exponent() const {
7916  return _internal_has_mip_max_activity_exponent();
7917 }
7918 inline void SatParameters::clear_mip_max_activity_exponent() {
7919  mip_max_activity_exponent_ = 53;
7920  _has_bits_[4] &= ~0x00000004u;
7921 }
7922 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::_internal_mip_max_activity_exponent() const {
7923  return mip_max_activity_exponent_;
7924 }
7925 inline ::PROTOBUF_NAMESPACE_ID::int32 SatParameters::mip_max_activity_exponent() const {
7926  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_max_activity_exponent)
7927  return _internal_mip_max_activity_exponent();
7928 }
7929 inline void SatParameters::_internal_set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value) {
7930  _has_bits_[4] |= 0x00000004u;
7931  mip_max_activity_exponent_ = value;
7932 }
7933 inline void SatParameters::set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value) {
7934  _internal_set_mip_max_activity_exponent(value);
7935  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_max_activity_exponent)
7936 }
7937 
7938 // optional double mip_check_precision = 128 [default = 0.0001];
7939 inline bool SatParameters::_internal_has_mip_check_precision() const {
7940  bool value = (_has_bits_[4] & 0x00000008u) != 0;
7941  return value;
7942 }
7943 inline bool SatParameters::has_mip_check_precision() const {
7944  return _internal_has_mip_check_precision();
7945 }
7946 inline void SatParameters::clear_mip_check_precision() {
7947  mip_check_precision_ = 0.0001;
7948  _has_bits_[4] &= ~0x00000008u;
7949 }
7950 inline double SatParameters::_internal_mip_check_precision() const {
7951  return mip_check_precision_;
7952 }
7953 inline double SatParameters::mip_check_precision() const {
7954  // @@protoc_insertion_point(field_get:operations_research.sat.SatParameters.mip_check_precision)
7955  return _internal_mip_check_precision();
7956 }
7957 inline void SatParameters::_internal_set_mip_check_precision(double value) {
7958  _has_bits_[4] |= 0x00000008u;
7959  mip_check_precision_ = value;
7960 }
7961 inline void SatParameters::set_mip_check_precision(double value) {
7962  _internal_set_mip_check_precision(value);
7963  // @@protoc_insertion_point(field_set:operations_research.sat.SatParameters.mip_check_precision)
7964 }
7965 
7966 #ifdef __GNUC__
7967  #pragma GCC diagnostic pop
7968 #endif // __GNUC__
7969 
7970 // @@protoc_insertion_point(namespace_scope)
7971 
7972 } // namespace sat
7973 } // namespace operations_research
7974 
7975 PROTOBUF_NAMESPACE_OPEN
7976 
7977 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_VariableOrder> : ::std::true_type {};
7978 template <>
7979 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_VariableOrder>() {
7980  return ::operations_research::sat::SatParameters_VariableOrder_descriptor();
7981 }
7982 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_Polarity> : ::std::true_type {};
7983 template <>
7984 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_Polarity>() {
7985  return ::operations_research::sat::SatParameters_Polarity_descriptor();
7986 }
7987 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm> : ::std::true_type {};
7988 template <>
7989 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm>() {
7990  return ::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_descriptor();
7991 }
7992 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm> : ::std::true_type {};
7993 template <>
7994 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm>() {
7995  return ::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_descriptor();
7996 }
7997 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ClauseProtection> : ::std::true_type {};
7998 template <>
7999 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ClauseProtection>() {
8000  return ::operations_research::sat::SatParameters_ClauseProtection_descriptor();
8001 }
8002 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_ClauseOrdering> : ::std::true_type {};
8003 template <>
8004 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_ClauseOrdering>() {
8005  return ::operations_research::sat::SatParameters_ClauseOrdering_descriptor();
8006 }
8007 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_RestartAlgorithm> : ::std::true_type {};
8008 template <>
8009 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_RestartAlgorithm>() {
8010  return ::operations_research::sat::SatParameters_RestartAlgorithm_descriptor();
8011 }
8012 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder> : ::std::true_type {};
8013 template <>
8014 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_MaxSatAssumptionOrder>() {
8015  return ::operations_research::sat::SatParameters_MaxSatAssumptionOrder_descriptor();
8016 }
8017 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm> : ::std::true_type {};
8018 template <>
8019 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm>() {
8020  return ::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_descriptor();
8021 }
8022 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_SearchBranching> : ::std::true_type {};
8023 template <>
8024 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_SearchBranching>() {
8025  return ::operations_research::sat::SatParameters_SearchBranching_descriptor();
8026 }
8027 template <> struct is_proto_enum< ::operations_research::sat::SatParameters_FPRoundingMethod> : ::std::true_type {};
8028 template <>
8029 inline const EnumDescriptor* GetEnumDescriptor< ::operations_research::sat::SatParameters_FPRoundingMethod>() {
8030  return ::operations_research::sat::SatParameters_FPRoundingMethod_descriptor();
8031 }
8032 
8033 PROTOBUF_NAMESPACE_CLOSE
8034 
8035 // @@protoc_insertion_point(global_scope)
8036 
8037 #include <google/protobuf/port_undef.inc>
8038 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_ortools_2fsat_2fsat_5fparameters_2eproto
operations_research::sat::PROTOBUF_FINAL::interleave_batch_size
::PROTOBUF_NAMESPACE_ID::int32 interleave_batch_size() const
operations_research::sat::PROTOBUF_FINAL::exploit_all_lp_solution
bool exploit_all_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::has_use_implied_bounds
bool has_use_implied_bounds() const
operations_research::sat::PROTOBUF_FINAL::has_glucose_decay_increment
bool has_glucose_decay_increment() const
operations_research::sat::PROTOBUF_FINAL::has_max_memory_in_mb
bool has_max_memory_in_mb() const
operations_research::sat::PROTOBUF_FINAL::clear_restart_algorithms
void clear_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::clear_presolve_blocked_clause
void clear_presolve_blocked_clause()
operations_research::sat::PROTOBUF_FINAL::optimize_with_core
bool optimize_with_core() const
operations_research::sat::PROTOBUF_FINAL::set_exploit_all_lp_solution
void set_exploit_all_lp_solution(bool value)
operations_research::sat::PROTOBUF_FINAL::max_deterministic_time
double max_deterministic_time() const
operations_research::sat::PROTOBUF_FINAL::has_probing_period_at_root
bool has_probing_period_at_root() const
operations_research::sat::PROTOBUF_FINAL::merge_no_overlap_work_limit
double merge_no_overlap_work_limit() const
operations_research::sat::PROTOBUF_FINAL::set_random_polarity_ratio
void set_random_polarity_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::clear_pseudo_cost_reliability_threshold
void clear_pseudo_cost_reliability_threshold()
operations_research::sat::PROTOBUF_FINAL::interleave_search
bool interleave_search() const
operations_research::sat::PROTOBUF_FINAL::clear_catch_sigint_signal
void clear_catch_sigint_signal()
operations_research::sat::PROTOBUF_FINAL::SearchBranching_Name
static const std::string & SearchBranching_Name(T enum_t_value)
Definition: sat_parameters.pb.h:792
operations_research::sat::PROTOBUF_FINAL::has_find_multiple_cores
bool has_find_multiple_cores() const
operations_research::sat::PROTOBUF_FINAL::set_use_precedences_in_disjunctive_constraint
void set_use_precedences_in_disjunctive_constraint(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_presolve
void clear_cp_model_presolve()
operations_research::sat::PROTOBUF_FINAL::has_permute_presolve_constraint_order
bool has_permute_presolve_constraint_order() const
operations_research::sat::PROTOBUF_FINAL::clear_presolve_probing_deterministic_time_limit
void clear_presolve_probing_deterministic_time_limit()
operations_research::sat::PROTOBUF_FINAL::has_restart_period
bool has_restart_period() const
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod
SatParameters_FPRoundingMethod FPRoundingMethod
Definition: sat_parameters.pb.h:803
operations_research::sat::PROTOBUF_FINAL::set_catch_sigint_signal
void set_catch_sigint_signal(bool value)
operations_research::sat::PROTOBUF_FINAL::SatParameters
SatParameters()
Definition: sat_parameters.pb.h:350
operations_research::sat::PROTOBUF_FINAL::clear_use_absl_random
void clear_use_absl_random()
operations_research::sat::PROTOBUF_FINAL::has_cp_model_use_sat_presolve
bool has_cp_model_use_sat_presolve() const
operations_research::sat::PROTOBUF_FINAL::also_bump_variables_in_conflict_reasons
bool also_bump_variables_in_conflict_reasons() const
operations_research::sat::PROTOBUF_FINAL::preferred_variable_order
::operations_research::sat::SatParameters_VariableOrder preferred_variable_order() const
operations_research::sat::PROTOBUF_FINAL::set_restart_algorithms
void set_restart_algorithms(int index, ::operations_research::sat::SatParameters_RestartAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::set_use_absl_random
void set_use_absl_random(bool value)
operations_research::sat::PROTOBUF_FINAL::has_add_cg_cuts
bool has_add_cg_cuts() const
operations_research::sat::PROTOBUF_FINAL::has_binary_minimization_algorithm
bool has_binary_minimization_algorithm() const
operations_research::sat::PROTOBUF_FINAL::has_instantiate_all_variables
bool has_instantiate_all_variables() const
operations_research::sat::PROTOBUF_FINAL::set_use_timetable_edge_finding_in_cumulative_constraint
void set_use_timetable_edge_finding_in_cumulative_constraint(bool value)
operations_research::sat::PROTOBUF_FINAL::set_use_feasibility_pump
void set_use_feasibility_pump(bool value)
operations_research::sat::PROTOBUF_FINAL::set_use_relaxation_lns
void set_use_relaxation_lns(bool value)
operations_research::sat::PROTOBUF_FINAL::has_glucose_decay_increment_period
bool has_glucose_decay_increment_period() const
operations_research::sat::PROTOBUF_FINAL::has_merge_no_overlap_work_limit
bool has_merge_no_overlap_work_limit() const
operations_research::sat::PROTOBUF_FINAL::set_mip_var_scaling
void set_mip_var_scaling(double value)
operations_research::sat::PROTOBUF_FINAL::has_binary_search_num_conflicts
bool has_binary_search_num_conflicts() const
operations_research::sat::PROTOBUF_FINAL::VariableOrder_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * VariableOrder_descriptor()
Definition: sat_parameters.pb.h:480
operations_research::sat::PROTOBUF_FINAL::swap
friend void swap(SatParameters &a, SatParameters &b)
Definition: sat_parameters.pb.h:397
operations_research::sat::PROTOBUF_FINAL::SatParameters
SatParameters(::PROTOBUF_NAMESPACE_ID::Arena *arena)
operations_research::sat::PROTOBUF_FINAL::max_clause_activity_value
double max_clause_activity_value() const
operations_research::sat::PROTOBUF_FINAL::VariableOrder_Name
static const std::string & VariableOrder_Name(T enum_t_value)
Definition: sat_parameters.pb.h:484
operations_research::sat::PROTOBUF_FINAL::has_num_conflicts_before_strategy_changes
bool has_num_conflicts_before_strategy_changes() const
operations_research::sat::PROTOBUF_FINAL::has_share_objective_bounds
bool has_share_objective_bounds() const
operations_research::sat::PROTOBUF_FINAL::default_restart_algorithms
const std::string & default_restart_algorithms() const
operations_research::sat::PROTOBUF_FINAL::set_minimize_with_propagation_restart_period
void set_minimize_with_propagation_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::use_lns_only
bool use_lns_only() const
operations_research::sat::PROTOBUF_FINAL::strategy_change_increase_ratio
double strategy_change_increase_ratio() const
operations_research::sat::PROTOBUF_FINAL::set_restart_dl_average_ratio
void set_restart_dl_average_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::MergeFrom
void MergeFrom(const SatParameters &from)
operations_research::sat::PROTOBUF_FINAL::set_initial_polarity
void set_initial_polarity(::operations_research::sat::SatParameters_Polarity value)
operations_research::sat::PROTOBUF_FINAL::set_search_branching
void set_search_branching(::operations_research::sat::SatParameters_SearchBranching value)
operations_research::sat::PROTOBUF_FINAL::presolve_bve_clause_weight
::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_clause_weight() const
operations_research::sat::PROTOBUF_FINAL::has_max_clause_activity_value
bool has_max_clause_activity_value() const
operations_research::sat::PROTOBUF_FINAL::GetReflection
static const ::PROTOBUF_NAMESPACE_ID::Reflection * GetReflection()
Definition: sat_parameters.pb.h:385
operations_research::sat::PROTOBUF_FINAL::minimize_core
bool minimize_core() const
operations_research::sat::PROTOBUF_FINAL::subsumption_during_conflict_analysis
bool subsumption_during_conflict_analysis() const
operations_research::sat::PROTOBUF_FINAL::clear_max_num_cuts
void clear_max_num_cuts()
operations_research::sat::PROTOBUF_FINAL::set_mip_max_activity_exponent
void set_mip_max_activity_exponent(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::add_restart_algorithms
void add_restart_algorithms(::operations_research::sat::SatParameters_RestartAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::has_mip_var_scaling
bool has_mip_var_scaling() const
operations_research::sat::PROTOBUF_FINAL::has_exploit_objective
bool has_exploit_objective() const
operations_research::sat::PROTOBUF_FINAL::has_interleave_search
bool has_interleave_search() const
operations_research::sat::PROTOBUF_FINAL::set_cut_active_count_decay
void set_cut_active_count_decay(double value)
operations_research::sat::PROTOBUF_FINAL::clear_add_zero_half_cuts
void clear_add_zero_half_cuts()
operations_research::sat::PROTOBUF_FINAL::clear_max_clause_activity_value
void clear_max_clause_activity_value()
operations_research::sat::PROTOBUF_FINAL::log_search_progress
bool log_search_progress() const
operations_research::sat::PROTOBUF_FINAL::set_use_branching_in_lp
void set_use_branching_in_lp(bool value)
operations_research::sat::PROTOBUF_FINAL::ClauseProtection_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * ClauseProtection_descriptor()
Definition: sat_parameters.pb.h:618
operations_research::sat::PROTOBUF_FINAL::set_max_variable_activity_value
void set_max_variable_activity_value(double value)
operations_research::sat::PROTOBUF_FINAL::use_optimization_hints
bool use_optimization_hints() const
operations_research::sat::PROTOBUF_FINAL::has_max_num_cuts
bool has_max_num_cuts() const
operations_research::sat::PROTOBUF_FINAL::clear_merge_no_overlap_work_limit
void clear_merge_no_overlap_work_limit()
operations_research::sat::PROTOBUF_FINAL::clear_initial_variables_activity
void clear_initial_variables_activity()
operations_research::sat::PROTOBUF_FINAL::set_add_mir_cuts
void set_add_mir_cuts(bool value)
operations_research::sat::PROTOBUF_FINAL::set_use_lns_only
void set_use_lns_only(bool value)
operations_research::sat::PROTOBUF_FINAL::enumerate_all_solutions
bool enumerate_all_solutions() const
operations_research::sat::PROTOBUF_FINAL::cp_model_use_sat_presolve
bool cp_model_use_sat_presolve() const
operations_research::sat::PROTOBUF_FINAL::SearchBranching
SatParameters_SearchBranching SearchBranching
Definition: sat_parameters.pb.h:763
operations_research::sat::PROTOBUF_FINAL::mip_check_precision
double mip_check_precision() const
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering_IsValid
static bool ClauseOrdering_IsValid(int value)
Definition: sat_parameters.pb.h:638
operations_research::sat::PROTOBUF_FINAL::clear_polish_lp_solution
void clear_polish_lp_solution()
operations_research::sat::PROTOBUF_FINAL::clear_lns_expand_intervals_in_constraint_graph
void clear_lns_expand_intervals_in_constraint_graph()
operations_research::sat::PROTOBUF_FINAL::clear_expand_reservoir_constraints
void clear_expand_reservoir_constraints()
operations_research::sat::PROTOBUF_FINAL::has_linearization_level
bool has_linearization_level() const
operations_research::sat::PROTOBUF_FINAL::find_multiple_cores
bool find_multiple_cores() const
operations_research::sat::PROTOBUF_FINAL::clear_use_timetable_edge_finding_in_cumulative_constraint
void clear_use_timetable_edge_finding_in_cumulative_constraint()
operations_research::sat::PROTOBUF_FINAL::has_optimize_with_core
bool has_optimize_with_core() const
operations_research::sat::PROTOBUF_FINAL::has_initial_variables_activity
bool has_initial_variables_activity() const
operations_research::sat::PROTOBUF_FINAL::clear_max_sat_stratification
void clear_max_sat_stratification()
operations_research::sat::PROTOBUF_FINAL::lns_focus_on_decision_variables
bool lns_focus_on_decision_variables() const
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * FPRoundingMethod_descriptor()
Definition: sat_parameters.pb.h:822
operations_research::sat::PROTOBUF_FINAL::Polarity_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * Polarity_descriptor()
Definition: sat_parameters.pb.h:516
operations_research::sat::PROTOBUF_FINAL::Clear
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final
operations_research::sat::PROTOBUF_FINAL::set_treat_binary_clauses_separately
void set_treat_binary_clauses_separately(bool value)
operations_research::sat::PROTOBUF_FINAL::presolve_bve_threshold
::PROTOBUF_NAMESPACE_ID::int32 presolve_bve_threshold() const
operations_research::sat::PROTOBUF_FINAL::clear_presolve_bve_threshold
void clear_presolve_bve_threshold()
operations_research::sat::PROTOBUF_FINAL::clause_activity_decay
double clause_activity_decay() const
operations_research::sat::PROTOBUF_FINAL::has_exploit_relaxation_solution
bool has_exploit_relaxation_solution() const
operations_research::sat::PROTOBUF_FINAL::clear_use_relaxation_lns
void clear_use_relaxation_lns()
operations_research::sat::PROTOBUF_FINAL::set_fill_tightened_domains_in_response
void set_fill_tightened_domains_in_response(bool value)
operations_research::sat::PROTOBUF_FINAL::SearchBranching_Parse
static bool SearchBranching_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SearchBranching *value)
Definition: sat_parameters.pb.h:798
operations_research::sat::PROTOBUF_FINAL::clear_mip_wanted_precision
void clear_mip_wanted_precision()
operations_research::sat::PROTOBUF_FINAL::set_use_sat_inprocessing
void set_use_sat_inprocessing(bool value)
operations_research::sat::PROTOBUF_FINAL::polarity_rephase_increment
::PROTOBUF_NAMESPACE_ID::int32 polarity_rephase_increment() const
operations_research::sat::PROTOBUF_FINAL::clear_also_bump_variables_in_conflict_reasons
void clear_also_bump_variables_in_conflict_reasons()
operations_research::sat::PROTOBUF_FINAL::clear_max_deterministic_time
void clear_max_deterministic_time()
operations_research::sat::PROTOBUF_FINAL::clear_keep_all_feasible_solutions_in_presolve
void clear_keep_all_feasible_solutions_in_presolve()
operations_research::sat::PROTOBUF_FINAL::has_cp_model_presolve
bool has_cp_model_presolve() const
operations_research::sat::PROTOBUF_FINAL::use_erwa_heuristic
bool use_erwa_heuristic() const
operations_research::sat::PROTOBUF_FINAL::set_name
void set_name(const char *value, size_t size)
operations_research::sat::PROTOBUF_FINAL::permute_presolve_constraint_order
bool permute_presolve_constraint_order() const
operations_research::sat::PROTOBUF_FINAL::clear_default_restart_algorithms
void clear_default_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::clear_variable_activity_decay
void clear_variable_activity_decay()
operations_research::sat::PROTOBUF_FINAL::has_use_feasibility_pump
bool has_use_feasibility_pump() const
operations_research::sat::PROTOBUF_FINAL::set_restart_period
void set_restart_period(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_use_combined_no_overlap
void clear_use_combined_no_overlap()
operations_research::sat::PROTOBUF_FINAL::has_max_cut_rounds_at_level_zero
bool has_max_cut_rounds_at_level_zero() const
operations_research::sat::PROTOBUF_FINAL::symmetry_level
::PROTOBUF_NAMESPACE_ID::int32 symmetry_level() const
operations_research::sat::PROTOBUF_FINAL::has_convert_intervals
bool has_convert_intervals() const
operations_research::sat::PROTOBUF_FINAL::clear_max_consecutive_inactive_count
void clear_max_consecutive_inactive_count()
operations_research::sat::PROTOBUF_FINAL::clear_optimize_with_max_hs
void clear_optimize_with_max_hs()
operations_research::sat::PROTOBUF_FINAL::use_feasibility_pump
bool use_feasibility_pump() const
operations_research::sat::PROTOBUF_FINAL::set_interleave_batch_size
void set_interleave_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_ordering
void set_clause_cleanup_ordering(::operations_research::sat::SatParameters_ClauseOrdering value)
operations_research::sat::PROTOBUF_FINAL::set_interleave_search
void set_interleave_search(bool value)
operations_research::sat::PROTOBUF_FINAL::set_cp_model_probing_level
void set_cp_model_probing_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::polish_lp_solution
bool polish_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::has_exploit_best_solution
bool has_exploit_best_solution() const
operations_research::sat::PROTOBUF_FINAL::cp_model_probing_level
::PROTOBUF_NAMESPACE_ID::int32 cp_model_probing_level() const
operations_research::sat::PROTOBUF_FINAL::has_presolve_extract_integer_enforcement
bool has_presolve_extract_integer_enforcement() const
operations_research::sat::PROTOBUF_FINAL::has_use_optional_variables
bool has_use_optional_variables() const
operations_research::sat::PROTOBUF_FINAL::set_polarity_rephase_increment
void set_polarity_rephase_increment(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::set_minimize_with_propagation_num_decisions
void set_minimize_with_propagation_num_decisions(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::set_repair_hint
void set_repair_hint(bool value)
operations_research::sat::PROTOBUF_FINAL::max_variable_activity_value
double max_variable_activity_value() const
operations_research::sat::PROTOBUF_FINAL::set_add_lp_constraints_lazily
void set_add_lp_constraints_lazily(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_binary_minimization_algorithm
void clear_binary_minimization_algorithm()
operations_research::sat::PROTOBUF_FINAL::clear_use_rins_lns
void clear_use_rins_lns()
operations_research::sat::PROTOBUF_FINAL::clear_use_implied_bounds
void clear_use_implied_bounds()
operations_research::sat::PROTOBUF_FINAL::release_default_restart_algorithms
std::string * release_default_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::clear_find_multiple_cores
void clear_find_multiple_cores()
operations_research::sat::PROTOBUF_FINAL::set_restart_lbd_average_ratio
void set_restart_lbd_average_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::descriptor
static const ::PROTOBUF_NAMESPACE_ID::Descriptor * descriptor()
Definition: sat_parameters.pb.h:379
operations_research::sat::PROTOBUF_FINAL::has_diversify_lns_params
bool has_diversify_lns_params() const
operations_research::sat::PROTOBUF_FINAL::set_auto_detect_greater_than_at_least_one_of
void set_auto_detect_greater_than_at_least_one_of(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_count_assumption_levels_in_lbd
void clear_count_assumption_levels_in_lbd()
operations_research::sat::PROTOBUF_FINAL::has_max_integer_rounding_scaling
bool has_max_integer_rounding_scaling() const
operations_research::sat::PROTOBUF_FINAL::restart_lbd_average_ratio
double restart_lbd_average_ratio() const
operations_research::sat::PROTOBUF_FINAL::clear_max_cut_rounds_at_level_zero
void clear_max_cut_rounds_at_level_zero()
operations_research::sat::PROTOBUF_FINAL::has_random_seed
bool has_random_seed() const
operations_research::sat::PROTOBUF_FINAL::set_minimize_reduction_during_pb_resolution
void set_minimize_reduction_during_pb_resolution(bool value)
operations_research::sat::PROTOBUF_FINAL::has_cp_model_probing_level
bool has_cp_model_probing_level() const
operations_research::sat::PROTOBUF_FINAL::clear_use_precedences_in_disjunctive_constraint
void clear_use_precedences_in_disjunctive_constraint()
operations_research::sat::PROTOBUF_FINAL::restart_running_window_size
::PROTOBUF_NAMESPACE_ID::int32 restart_running_window_size() const
operations_research::sat::PROTOBUF_FINAL::stop_after_first_solution
bool stop_after_first_solution() const
operations_research::sat::PROTOBUF_FINAL::has_variable_activity_decay
bool has_variable_activity_decay() const
operations_research::sat::PROTOBUF_FINAL::num_search_workers
::PROTOBUF_NAMESPACE_ID::int32 num_search_workers() const
operations_research::sat::PROTOBUF_FINAL::set_name
void set_name(const std::string &value)
operations_research::sat::PROTOBUF_FINAL::add_mir_cuts
bool add_mir_cuts() const
operations_research::sat::PROTOBUF_FINAL::clear_exploit_all_lp_solution
void clear_exploit_all_lp_solution()
operations_research::sat::PROTOBUF_FINAL::clear_reduce_memory_usage_in_interleave_mode
void clear_reduce_memory_usage_in_interleave_mode()
operations_research::sat::PROTOBUF_FINAL::has_blocking_restart_multiplier
bool has_blocking_restart_multiplier() const
operations_research::sat::PROTOBUF_FINAL::has_use_blocking_restart
bool has_use_blocking_restart() const
operations_research::sat::PROTOBUF_FINAL::clear_max_number_of_conflicts
void clear_max_number_of_conflicts()
operations_research::sat::PROTOBUF_FINAL::clear_glucose_max_decay
void clear_glucose_max_decay()
operations_research::sat::PROTOBUF_FINAL::has_presolve_bva_threshold
bool has_presolve_bva_threshold() const
operations_research::sat::PROTOBUF_FINAL::has_fill_logs_in_response
bool has_fill_logs_in_response() const
operations_research::sat::PROTOBUF_FINAL::set_presolve_bve_threshold
void set_presolve_bve_threshold(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_min_orthogonality_for_lp_constraints
bool has_min_orthogonality_for_lp_constraints() const
operations_research::sat::PROTOBUF_FINAL::has_restart_lbd_average_ratio
bool has_restart_lbd_average_ratio() const
operations_research::sat::PROTOBUF_FINAL::set_add_clique_cuts
void set_add_clique_cuts(bool value)
operations_research::sat::PROTOBUF_FINAL::set_optimize_with_core
void set_optimize_with_core(bool value)
operations_research::sat::PROTOBUF_FINAL::use_pb_resolution
bool use_pb_resolution() const
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_ordering
void clear_clause_cleanup_ordering()
operations_research::sat::PROTOBUF_FINAL::set_default_restart_algorithms
void set_default_restart_algorithms(const char *value)
operations_research::sat::PROTOBUF_FINAL::clear_new_constraints_batch_size
void clear_new_constraints_batch_size()
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder_IsValid
static bool MaxSatAssumptionOrder_IsValid(int value)
Definition: sat_parameters.pb.h:706
operations_research::sat::PROTOBUF_FINAL::set_default_restart_algorithms
void set_default_restart_algorithms(const char *value, size_t size)
operations_research::sat::PROTOBUF_FINAL::clear_max_variable_activity_value
void clear_max_variable_activity_value()
operations_research::sat::PROTOBUF_FINAL::presolve_substitution_level
::PROTOBUF_NAMESPACE_ID::int32 presolve_substitution_level() const
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm_Parse
static bool BinaryMinizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BinaryMinizationAlgorithm *value)
Definition: sat_parameters.pb.h:596
operations_research::sat::PROTOBUF_FINAL::has_preferred_variable_order
bool has_preferred_variable_order() const
operations_research::sat::PROTOBUF_FINAL::use_implied_bounds
bool use_implied_bounds() const
operations_research::sat::PROTOBUF_FINAL::set_mip_automatically_scale_variables
void set_mip_automatically_scale_variables(bool value)
operations_research::sat::PROTOBUF_FINAL::set_also_bump_variables_in_conflict_reasons
void set_also_bump_variables_in_conflict_reasons(bool value)
operations_research::sat::PROTOBUF_FINAL::has_use_phase_saving
bool has_use_phase_saving() const
operations_research::sat::PROTOBUF_FINAL::has_exploit_all_lp_solution
bool has_exploit_all_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::has_presolve_substitution_level
bool has_presolve_substitution_level() const
operations_research::sat::PROTOBUF_FINAL::mip_wanted_precision
double mip_wanted_precision() const
operations_research::sat::PROTOBUF_FINAL::set_new_constraints_batch_size
void set_new_constraints_batch_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_new_constraints_batch_size
bool has_new_constraints_batch_size() const
operations_research::sat::PROTOBUF_FINAL::clear_optimize_with_core
void clear_optimize_with_core()
operations_research::sat::PROTOBUF_FINAL::set_use_disjunctive_constraint_in_cumulative_constraint
void set_use_disjunctive_constraint_in_cumulative_constraint(bool value)
operations_research::sat::PROTOBUF_FINAL::set_max_memory_in_mb
void set_max_memory_in_mb(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::clear_expand_automaton_constraints
void clear_expand_automaton_constraints()
operations_research::sat::PROTOBUF_FINAL::has_use_branching_in_lp
bool has_use_branching_in_lp() const
operations_research::sat::PROTOBUF_FINAL::clear_binary_search_num_conflicts
void clear_binary_search_num_conflicts()
operations_research::sat::PROTOBUF_FINAL::has_add_knapsack_cuts
bool has_add_knapsack_cuts() const
operations_research::sat::PROTOBUF_FINAL::has_mip_wanted_precision
bool has_mip_wanted_precision() const
operations_research::sat::PROTOBUF_FINAL::has_reduce_memory_usage_in_interleave_mode
bool has_reduce_memory_usage_in_interleave_mode() const
operations_research::sat::PROTOBUF_FINAL::set_reduce_memory_usage_in_interleave_mode
void set_reduce_memory_usage_in_interleave_mode(bool value)
operations_research::sat::PROTOBUF_FINAL::keep_all_feasible_solutions_in_presolve
bool keep_all_feasible_solutions_in_presolve() const
operations_research::sat::PROTOBUF_FINAL::ClauseProtection_IsValid
static bool ClauseProtection_IsValid(int value)
Definition: sat_parameters.pb.h:608
operations_research::sat::PROTOBUF_FINAL::initial_polarity
::operations_research::sat::SatParameters_Polarity initial_polarity() const
operations_research::sat::PROTOBUF_FINAL::clear_max_sat_assumption_order
void clear_max_sat_assumption_order()
operations_research::sat::PROTOBUF_FINAL::set_expand_alldiff_constraints
void set_expand_alldiff_constraints(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_initial_polarity
void clear_initial_polarity()
operations_research::sat::PROTOBUF_FINAL::repair_hint
bool repair_hint() const
operations_research::sat::PROTOBUF_FINAL::Polarity_Name
static const std::string & Polarity_Name(T enum_t_value)
Definition: sat_parameters.pb.h:520
operations_research::sat::PROTOBUF_FINAL::clear_mip_automatically_scale_variables
void clear_mip_automatically_scale_variables()
operations_research::sat::PROTOBUF_FINAL::MergeFrom
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message &from) final
operations_research::sat::PROTOBUF_FINAL::clear_use_branching_in_lp
void clear_use_branching_in_lp()
operations_research::sat::PROTOBUF_FINAL::fp_rounding
::operations_research::sat::SatParameters_FPRoundingMethod fp_rounding() const
operations_research::sat::PROTOBUF_FINAL::clear_clause_activity_decay
void clear_clause_activity_decay()
operations_research::sat::PROTOBUF_FINAL::set_expand_element_constraints
void set_expand_element_constraints(bool value)
operations_research::sat::PROTOBUF_FINAL::has_default_restart_algorithms
bool has_default_restart_algorithms() const
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm_IsValid
static bool ConflictMinimizationAlgorithm_IsValid(int value)
Definition: sat_parameters.pb.h:540
operations_research::sat::PROTOBUF_FINAL::clear_name
void clear_name()
operations_research::sat::PROTOBUF_FINAL::set_max_num_cuts
void set_max_num_cuts(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_add_mir_cuts
void clear_add_mir_cuts()
operations_research::sat::PROTOBUF_FINAL::has_also_bump_variables_in_conflict_reasons
bool has_also_bump_variables_in_conflict_reasons() const
operations_research::sat::PROTOBUF_FINAL::set_find_multiple_cores
void set_find_multiple_cores(bool value)
operations_research::sat::PROTOBUF_FINAL::has_cut_active_count_decay
bool has_cut_active_count_decay() const
operations_research::sat::PROTOBUF_FINAL::mutable_name
std::string * mutable_name()
operations_research::sat::PROTOBUF_FINAL::clear_exploit_best_solution
void clear_exploit_best_solution()
operations_research::sat::PROTOBUF_FINAL::set_boolean_encoding_level
void set_boolean_encoding_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::use_relaxation_lns
bool use_relaxation_lns() const
operations_research::sat::PROTOBUF_FINAL::has_minimization_algorithm
bool has_minimization_algorithm() const
operations_research::sat::PROTOBUF_FINAL::clear_exploit_relaxation_solution
void clear_exploit_relaxation_solution()
operations_research::sat::PROTOBUF_FINAL::set_permute_variable_randomly
void set_permute_variable_randomly(bool value)
operations_research::sat::PROTOBUF_FINAL::operator=
SatParameters & operator=(const SatParameters &from)
Definition: sat_parameters.pb.h:359
operations_research::sat::PROTOBUF_FINAL::convert_intervals
bool convert_intervals() const
operations_research::sat::PROTOBUF_FINAL::has_only_add_cuts_at_level_zero
bool has_only_add_cuts_at_level_zero() const
operations_research::sat::PROTOBUF_FINAL::use_rins_lns
bool use_rins_lns() const
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * RestartAlgorithm_descriptor()
Definition: sat_parameters.pb.h:684
operations_research::sat::PROTOBUF_FINAL::clear_blocking_restart_multiplier
void clear_blocking_restart_multiplier()
operations_research::sat::PROTOBUF_FINAL::expand_reservoir_constraints
bool expand_reservoir_constraints() const
operations_research::sat::PROTOBUF_FINAL::has_cp_model_postsolve_with_full_solver
bool has_cp_model_postsolve_with_full_solver() const
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_probing_level
void clear_cp_model_probing_level()
operations_research::sat::PROTOBUF_FINAL::set_pseudo_cost_reliability_threshold
void set_pseudo_cost_reliability_threshold(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::set_cp_model_max_num_presolve_operations
void set_cp_model_max_num_presolve_operations(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_auto_detect_greater_than_at_least_one_of
bool has_auto_detect_greater_than_at_least_one_of() const
operations_research::sat::PROTOBUF_FINAL::has_num_search_workers
bool has_num_search_workers() const
operations_research::sat::PROTOBUF_FINAL::set_cp_model_postsolve_with_full_solver
void set_cp_model_postsolve_with_full_solver(bool value)
operations_research::sat::PROTOBUF_FINAL::use_precedences_in_disjunctive_constraint
bool use_precedences_in_disjunctive_constraint() const
operations_research::sat::PROTOBUF_FINAL::release_name
std::string * release_name()
operations_research::sat::PROTOBUF_FINAL::has_max_consecutive_inactive_count
bool has_max_consecutive_inactive_count() const
operations_research::sat::PROTOBUF_FINAL::treat_binary_clauses_separately
bool treat_binary_clauses_separately() const
operations_research::sat::PROTOBUF_FINAL::~SatParameters
virtual ~SatParameters()
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_protection
::operations_research::sat::SatParameters_ClauseProtection clause_cleanup_protection() const
operations_research::sat::PROTOBUF_FINAL::search_branching
::operations_research::sat::SatParameters_SearchBranching search_branching() const
operations_research::sat::PROTOBUF_FINAL::has_use_timetable_edge_finding_in_cumulative_constraint
bool has_use_timetable_edge_finding_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::has_use_relaxation_lns
bool has_use_relaxation_lns() const
operations_research::sat::PROTOBUF_FINAL::clear_use_sat_inprocessing
void clear_use_sat_inprocessing()
operations_research::sat::PROTOBUF_FINAL::blocking_restart_multiplier
double blocking_restart_multiplier() const
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_lbd_bound
bool has_clause_cleanup_lbd_bound() const
operations_research::sat::PROTOBUF_FINAL::SatParameters
SatParameters(SatParameters &&from) noexcept
Definition: sat_parameters.pb.h:354
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm_IsValid
static bool MaxSatStratificationAlgorithm_IsValid(int value)
Definition: sat_parameters.pb.h:738
operations_research::sat::PROTOBUF_FINAL::Polarity
SatParameters_Polarity Polarity
Definition: sat_parameters.pb.h:495
operations_research::sat::PROTOBUF_FINAL::has_max_number_of_conflicts
bool has_max_number_of_conflicts() const
operations_research::sat::PROTOBUF_FINAL::has_max_presolve_iterations
bool has_max_presolve_iterations() const
operations_research::sat::PROTOBUF_FINAL::set_max_integer_rounding_scaling
void set_max_integer_rounding_scaling(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_restart_dl_average_ratio
bool has_restart_dl_average_ratio() const
operations_research::sat::PROTOBUF_FINAL::set_minimize_core
void set_minimize_core(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_use_optional_variables
void clear_use_optional_variables()
operations_research::sat::PROTOBUF_FINAL::clear_use_exact_lp_reason
void clear_use_exact_lp_reason()
operations_research::sat::PROTOBUF_FINAL::has_treat_binary_clauses_separately
bool has_treat_binary_clauses_separately() const
operations_research::sat::PROTOBUF_FINAL::glucose_max_decay
double glucose_max_decay() const
operations_research::sat::PROTOBUF_FINAL::expand_automaton_constraints
bool expand_automaton_constraints() const
operations_research::sat::PROTOBUF_FINAL::set_use_blocking_restart
void set_use_blocking_restart(bool value)
operations_research::sat::PROTOBUF_FINAL::has_use_disjunctive_constraint_in_cumulative_constraint
bool has_use_disjunctive_constraint_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_lbd_bound
void clear_clause_cleanup_lbd_bound()
operations_research::sat::PROTOBUF_FINAL::presolve_blocked_clause
bool presolve_blocked_clause() const
operations_research::sat::PROTOBUF_FINAL::clear_linearization_level
void clear_linearization_level()
operations_research::sat::PROTOBUF_FINAL::reduce_memory_usage_in_interleave_mode
bool reduce_memory_usage_in_interleave_mode() const
operations_research::sat::PROTOBUF_FINAL::set_relative_gap_limit
void set_relative_gap_limit(double value)
operations_research::sat::PROTOBUF_FINAL::max_all_diff_cut_size
::PROTOBUF_NAMESPACE_ID::int32 max_all_diff_cut_size() const
operations_research::sat::PROTOBUF_FINAL::has_blocking_restart_window_size
bool has_blocking_restart_window_size() const
operations_research::sat::PROTOBUF_FINAL::max_num_cuts
::PROTOBUF_NAMESPACE_ID::int32 max_num_cuts() const
operations_research::sat::PROTOBUF_FINAL::set_permute_presolve_constraint_order
void set_permute_presolve_constraint_order(bool value)
operations_research::sat::PROTOBUF_FINAL::relative_gap_limit
double relative_gap_limit() const
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder_Parse
static bool MaxSatAssumptionOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MaxSatAssumptionOrder *value)
Definition: sat_parameters.pb.h:726
operations_research::sat::PROTOBUF_FINAL::minimize_reduction_during_pb_resolution
bool minimize_reduction_during_pb_resolution() const
operations_research::sat::PROTOBUF_FINAL::catch_sigint_signal
bool catch_sigint_signal() const
operations_research::sat::PROTOBUF_FINAL::clear_only_add_cuts_at_level_zero
void clear_only_add_cuts_at_level_zero()
operations_research::sat::PROTOBUF_FINAL::expand_alldiff_constraints
bool expand_alldiff_constraints() const
operations_research::sat::PROTOBUF_FINAL::linearization_level
::PROTOBUF_NAMESPACE_ID::int32 linearization_level() const
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering_Parse
static bool ClauseOrdering_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClauseOrdering *value)
Definition: sat_parameters.pb.h:658
operations_research::sat::PROTOBUF_FINAL::use_combined_no_overlap
bool use_combined_no_overlap() const
operations_research::sat::PROTOBUF_FINAL::clear_add_lin_max_cuts
void clear_add_lin_max_cuts()
operations_research::sat::PROTOBUF_FINAL::set_strategy_change_increase_ratio
void set_strategy_change_increase_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::clear_mip_max_bound
void clear_mip_max_bound()
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_protection
void clear_clause_cleanup_protection()
operations_research::sat::PROTOBUF_FINAL::clear_use_lns_only
void clear_use_lns_only()
operations_research::sat::PROTOBUF_FINAL::set_cp_model_presolve
void set_cp_model_presolve(bool value)
operations_research::sat::PROTOBUF_FINAL::set_max_presolve_iterations
void set_max_presolve_iterations(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_protection
bool has_clause_cleanup_protection() const
operations_research::sat::PROTOBUF_FINAL::set_exploit_objective
void set_exploit_objective(bool value)
operations_research::sat::PROTOBUF_FINAL::mip_max_activity_exponent
::PROTOBUF_NAMESPACE_ID::int32 mip_max_activity_exponent() const
operations_research::sat::PROTOBUF_FINAL::has_presolve_bve_clause_weight
bool has_presolve_bve_clause_weight() const
operations_research::sat::PROTOBUF_FINAL::set_use_rins_lns
void set_use_rins_lns(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_use_blocking_restart
void clear_use_blocking_restart()
operations_research::sat::PROTOBUF_FINAL::has_pseudo_cost_reliability_threshold
bool has_pseudo_cost_reliability_threshold() const
operations_research::sat::PROTOBUF_FINAL::use_sat_inprocessing
bool use_sat_inprocessing() const
operations_research::sat::PROTOBUF_FINAL::VariableOrder_IsValid
static bool VariableOrder_IsValid(int value)
Definition: sat_parameters.pb.h:470
operations_research::sat::PROTOBUF_FINAL::variable_activity_decay
double variable_activity_decay() const
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_period
void clear_clause_cleanup_period()
operations_research::sat::PROTOBUF_FINAL::has_hint_conflict_limit
bool has_hint_conflict_limit() const
operations_research::sat::PROTOBUF_FINAL::presolve_probing_deterministic_time_limit
double presolve_probing_deterministic_time_limit() const
operations_research::sat::PROTOBUF_FINAL::clear_mip_check_precision
void clear_mip_check_precision()
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_ordering
bool has_clause_cleanup_ordering() const
operations_research::sat::PROTOBUF_FINAL::clear_num_search_workers
void clear_num_search_workers()
operations_research::sat::PROTOBUF_FINAL::has_cp_model_max_num_presolve_operations
bool has_cp_model_max_num_presolve_operations() const
operations_research::sat::PROTOBUF_FINAL::has_cover_optimization
bool has_cover_optimization() const
operations_research::sat::PROTOBUF_FINAL::clear_presolve_bve_clause_weight
void clear_presolve_bve_clause_weight()
operations_research::sat::PROTOBUF_FINAL::has_use_pb_resolution
bool has_use_pb_resolution() const
operations_research::sat::PROTOBUF_FINAL::Polarity_Parse
static bool Polarity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Polarity *value)
Definition: sat_parameters.pb.h:526
operations_research::sat::PROTOBUF_FINAL::has_presolve_bve_threshold
bool has_presolve_bve_threshold() const
operations_research::sat::PROTOBUF_FINAL::set_use_exact_lp_reason
void set_use_exact_lp_reason(bool value)
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm
SatParameters_MaxSatStratificationAlgorithm MaxSatStratificationAlgorithm
Definition: sat_parameters.pb.h:731
operations_research::sat::PROTOBUF_FINAL::has_disable_constraint_expansion
bool has_disable_constraint_expansion() const
operations_research::sat::PROTOBUF_FINAL::CopyFrom
void CopyFrom(const SatParameters &from)
operations_research::sat::PROTOBUF_FINAL::operator=
SatParameters & operator=(SatParameters &&from) noexcept
Definition: sat_parameters.pb.h:363
operations_research::sat::PROTOBUF_FINAL::set_use_overload_checker_in_cumulative_constraint
void set_use_overload_checker_in_cumulative_constraint(bool value)
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_target
void set_clause_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_search_branching
bool has_search_branching() const
operations_research::sat::PROTOBUF_FINAL::has_stop_after_first_solution
bool has_stop_after_first_solution() const
operations_research::sat::PROTOBUF_FINAL::set_cover_optimization
void set_cover_optimization(bool value)
operations_research::sat::PROTOBUF_FINAL::mutable_default_restart_algorithms
std::string * mutable_default_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::has_use_erwa_heuristic
bool has_use_erwa_heuristic() const
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm_Parse
static bool ConflictMinimizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ConflictMinimizationAlgorithm *value)
Definition: sat_parameters.pb.h:560
operations_research::sat::PROTOBUF_FINAL::clear_exploit_objective
void clear_exploit_objective()
operations_research::sat::PROTOBUF_FINAL::has_boolean_encoding_level
bool has_boolean_encoding_level() const
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * ConflictMinimizationAlgorithm_descriptor()
Definition: sat_parameters.pb.h:550
operations_research::sat::PROTOBUF_FINAL::share_objective_bounds
bool share_objective_bounds() const
operations_research::sat::PROTOBUF_FINAL::clear_max_all_diff_cut_size
void clear_max_all_diff_cut_size()
operations_research::sat::PROTOBUF_FINAL::set_max_number_of_conflicts
void set_max_number_of_conflicts(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::clear_auto_detect_greater_than_at_least_one_of
void clear_auto_detect_greater_than_at_least_one_of()
operations_research::sat::PROTOBUF_FINAL::has_merge_at_most_one_work_limit
bool has_merge_at_most_one_work_limit() const
operations_research::sat::PROTOBUF_FINAL::mutable_restart_algorithms
::PROTOBUF_NAMESPACE_ID::RepeatedField< int > * mutable_restart_algorithms()
operations_research::sat::PROTOBUF_FINAL::clear_use_pb_resolution
void clear_use_pb_resolution()
operations_research::sat::PROTOBUF_FINAL::clear_stop_after_presolve
void clear_stop_after_presolve()
operations_research::sat::PROTOBUF_FINAL::clear_randomize_search
void clear_randomize_search()
operations_research::sat::PROTOBUF_FINAL::has_minimize_with_propagation_restart_period
bool has_minimize_with_propagation_restart_period() const
operations_research::sat::PROTOBUF_FINAL::set_only_add_cuts_at_level_zero
void set_only_add_cuts_at_level_zero(bool value)
operations_research::sat::PROTOBUF_FINAL::set_min_orthogonality_for_lp_constraints
void set_min_orthogonality_for_lp_constraints(double value)
operations_research::sat::PROTOBUF_FINAL::cover_optimization
bool cover_optimization() const
operations_research::sat::PROTOBUF_FINAL::use_branching_in_lp
bool use_branching_in_lp() const
operations_research::sat::PROTOBUF_FINAL::clear_strategy_change_increase_ratio
void clear_strategy_change_increase_ratio()
operations_research::sat::PROTOBUF_FINAL::set_search_randomization_tolerance
void set_search_randomization_tolerance(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::has_add_lin_max_cuts
bool has_add_lin_max_cuts() const
operations_research::sat::PROTOBUF_FINAL::set_merge_at_most_one_work_limit
void set_merge_at_most_one_work_limit(double value)
operations_research::sat::PROTOBUF_FINAL::set_polish_lp_solution
void set_polish_lp_solution(bool value)
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod_IsValid
static bool FPRoundingMethod_IsValid(int value)
Definition: sat_parameters.pb.h:812
operations_research::sat::PROTOBUF_FINAL::Polarity_IsValid
static bool Polarity_IsValid(int value)
Definition: sat_parameters.pb.h:506
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm
SatParameters_BinaryMinizationAlgorithm BinaryMinizationAlgorithm
Definition: sat_parameters.pb.h:565
operations_research::sat::PROTOBUF_FINAL::set_binary_search_num_conflicts
void set_binary_search_num_conflicts(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_clause_cleanup_target
void clear_clause_cleanup_target()
operations_research::sat::PROTOBUF_FINAL::clear_expand_alldiff_constraints
void clear_expand_alldiff_constraints()
operations_research::sat::PROTOBUF_FINAL::merge_at_most_one_work_limit
double merge_at_most_one_work_limit() const
operations_research::sat::PROTOBUF_FINAL::set_linearization_level
void set_linearization_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_minimization_algorithm
void clear_minimization_algorithm()
operations_research::sat::PROTOBUF_FINAL::ClauseProtection_Name
static const std::string & ClauseProtection_Name(T enum_t_value)
Definition: sat_parameters.pb.h:622
operations_research::sat::PROTOBUF_FINAL::set_blocking_restart_window_size
void set_blocking_restart_window_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::restart_period
::PROTOBUF_NAMESPACE_ID::int32 restart_period() const
operations_research::sat::PROTOBUF_FINAL::set_preferred_variable_order
void set_preferred_variable_order(::operations_research::sat::SatParameters_VariableOrder value)
operations_research::sat::PROTOBUF_FINAL::clear_cut_cleanup_target
void clear_cut_cleanup_target()
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_period
bool has_clause_cleanup_period() const
operations_research::sat::PROTOBUF_FINAL::has_clause_cleanup_target
bool has_clause_cleanup_target() const
operations_research::sat::PROTOBUF_FINAL::set_presolve_substitution_level
void set_presolve_substitution_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_name
bool has_name() const
operations_research::sat::PROTOBUF_FINAL::use_overload_checker_in_cumulative_constraint
bool use_overload_checker_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::max_sat_stratification
::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm max_sat_stratification() const
operations_research::sat::PROTOBUF_FINAL::has_catch_sigint_signal
bool has_catch_sigint_signal() const
operations_research::sat::PROTOBUF_FINAL::set_pb_cleanup_increment
void set_pb_cleanup_increment(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::set_diversify_lns_params
void set_diversify_lns_params(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_merge_at_most_one_work_limit
void clear_merge_at_most_one_work_limit()
operations_research::sat::PROTOBUF_FINAL::set_use_optimization_hints
void set_use_optimization_hints(bool value)
operations_research::sat::PROTOBUF_FINAL::set_presolve_bva_threshold
void set_presolve_bva_threshold(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_exploit_integer_lp_solution
bool has_exploit_integer_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * MaxSatStratificationAlgorithm_descriptor()
Definition: sat_parameters.pb.h:748
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm_Name
static const std::string & MaxSatStratificationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:752
operations_research::sat::PROTOBUF_FINAL::clear_random_seed
void clear_random_seed()
operations_research::sat::PROTOBUF_FINAL::has_use_absl_random
bool has_use_absl_random() const
operations_research::sat::PROTOBUF_FINAL::set_stop_after_first_solution
void set_stop_after_first_solution(bool value)
operations_research::sat::PROTOBUF_FINAL::New
SatParameters * New(::PROTOBUF_NAMESPACE_ID::Arena *arena) const final
Definition: sat_parameters.pb.h:420
operations_research::sat::PROTOBUF_FINAL::clear_preferred_variable_order
void clear_preferred_variable_order()
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod_Name
static const std::string & FPRoundingMethod_Name(T enum_t_value)
Definition: sat_parameters.pb.h:826
operations_research::sat::PROTOBUF_FINAL::has_polish_lp_solution
bool has_polish_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::has_max_variable_activity_value
bool has_max_variable_activity_value() const
operations_research::sat::PROTOBUF_FINAL::CopyFrom
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message &from) final
operations_research::sat::PROTOBUF_FINAL::has_keep_all_feasible_solutions_in_presolve
bool has_keep_all_feasible_solutions_in_presolve() const
operations_research::sat::PROTOBUF_FINAL::set_max_deterministic_time
void set_max_deterministic_time(double value)
operations_research::sat::PROTOBUF_FINAL::clear_glucose_decay_increment_period
void clear_glucose_decay_increment_period()
operations_research::sat::PROTOBUF_FINAL::set_random_branches_ratio
void set_random_branches_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::has_expand_table_constraints
bool has_expand_table_constraints() const
operations_research::sat::PROTOBUF_FINAL::set_mip_check_precision
void set_mip_check_precision(double value)
operations_research::sat::PROTOBUF_FINAL::has_presolve_probing_deterministic_time_limit
bool has_presolve_probing_deterministic_time_limit() const
operations_research::sat::PROTOBUF_FINAL::expand_element_constraints
bool expand_element_constraints() const
operations_research::sat::PROTOBUF_FINAL::UnsafeArenaSwap
void UnsafeArenaSwap(SatParameters *other)
Definition: sat_parameters.pb.h:408
operations_research::sat::PROTOBUF_FINAL::has_lns_focus_on_decision_variables
bool has_lns_focus_on_decision_variables() const
operations_research::sat::PROTOBUF_FINAL::set_max_sat_assumption_order
void set_max_sat_assumption_order(::operations_research::sat::SatParameters_MaxSatAssumptionOrder value)
operations_research::sat::PROTOBUF_FINAL::has_restart_running_window_size
bool has_restart_running_window_size() const
operations_research::sat::PROTOBUF_FINAL::set_glucose_max_decay
void set_glucose_max_decay(double value)
operations_research::sat::PROTOBUF_FINAL::set_glucose_decay_increment
void set_glucose_decay_increment(double value)
operations_research::sat::PROTOBUF_FINAL::max_consecutive_inactive_count
::PROTOBUF_NAMESPACE_ID::int32 max_consecutive_inactive_count() const
operations_research::sat::PROTOBUF_FINAL::set_mip_wanted_precision
void set_mip_wanted_precision(double value)
operations_research::sat::PROTOBUF_FINAL::has_fp_rounding
bool has_fp_rounding() const
operations_research::sat::PROTOBUF_FINAL::has_add_clique_cuts
bool has_add_clique_cuts() const
operations_research::sat::PROTOBUF_FINAL::clear_expand_table_constraints
void clear_expand_table_constraints()
operations_research::sat::PROTOBUF_FINAL::exploit_best_solution
bool exploit_best_solution() const
operations_research::sat::PROTOBUF_FINAL::cut_max_active_count_value
double cut_max_active_count_value() const
operations_research::sat::PROTOBUF_FINAL::has_expand_alldiff_constraints
bool has_expand_alldiff_constraints() const
operations_research::sat::PROTOBUF_FINAL::has_repair_hint
bool has_repair_hint() const
operations_research::sat::PROTOBUF_FINAL::max_memory_in_mb
::PROTOBUF_NAMESPACE_ID::int64 max_memory_in_mb() const
operations_research::sat::PROTOBUF_FINAL::set_minimization_algorithm
void set_minimization_algorithm(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::set_clause_activity_decay
void set_clause_activity_decay(double value)
operations_research::sat::PROTOBUF_FINAL::set_optimize_with_max_hs
void set_optimize_with_max_hs(bool value)
operations_research::sat::PROTOBUF_FINAL::fill_logs_in_response
bool fill_logs_in_response() const
operations_research::sat::PROTOBUF_FINAL::use_phase_saving
bool use_phase_saving() const
operations_research::sat::PROTOBUF_FINAL::num_conflicts_before_strategy_changes
::PROTOBUF_NAMESPACE_ID::int32 num_conflicts_before_strategy_changes() const
operations_research::sat::PROTOBUF_FINAL::set_expand_automaton_constraints
void set_expand_automaton_constraints(bool value)
operations_research::sat::PROTOBUF_FINAL::pb_cleanup_increment
::PROTOBUF_NAMESPACE_ID::int32 pb_cleanup_increment() const
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_ordering
::operations_research::sat::SatParameters_ClauseOrdering clause_cleanup_ordering() const
operations_research::sat::PROTOBUF_FINAL::set_max_clause_activity_value
void set_max_clause_activity_value(double value)
operations_research::sat::PROTOBUF_FINAL::set_blocking_restart_multiplier
void set_blocking_restart_multiplier(double value)
operations_research::sat::PROTOBUF_FINAL::mip_automatically_scale_variables
bool mip_automatically_scale_variables() const
operations_research::sat::PROTOBUF_FINAL::clear_max_integer_rounding_scaling
void clear_max_integer_rounding_scaling()
operations_research::sat::PROTOBUF_FINAL::clear_lns_focus_on_decision_variables
void clear_lns_focus_on_decision_variables()
operations_research::sat::PROTOBUF_FINAL::has_random_branches_ratio
bool has_random_branches_ratio() const
operations_research::sat::PROTOBUF_FINAL::has_minimize_reduction_during_pb_resolution
bool has_minimize_reduction_during_pb_resolution() const
operations_research::sat::PROTOBUF_FINAL::use_disjunctive_constraint_in_cumulative_constraint
bool use_disjunctive_constraint_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::set_enumerate_all_solutions
void set_enumerate_all_solutions(bool value)
operations_research::sat::PROTOBUF_FINAL::set_pb_cleanup_ratio
void set_pb_cleanup_ratio(double value)
operations_research::sat::PROTOBUF_FINAL::clear_share_level_zero_bounds
void clear_share_level_zero_bounds()
operations_research::sat::PROTOBUF_FINAL::has_max_time_in_seconds
bool has_max_time_in_seconds() const
operations_research::sat::PROTOBUF_FINAL::minimization_algorithm
::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm minimization_algorithm() const
operations_research::sat::PROTOBUF_FINAL::add_lin_max_cuts
bool add_lin_max_cuts() const
operations_research::sat::PROTOBUF_FINAL::set_randomize_search
void set_randomize_search(bool value)
operations_research::sat::PROTOBUF_FINAL::set_stop_after_presolve
void set_stop_after_presolve(bool value)
operations_research::sat::PROTOBUF_FINAL::cp_model_presolve
bool cp_model_presolve() const
operations_research::sat::PROTOBUF_FINAL::fill_tightened_domains_in_response
bool fill_tightened_domains_in_response() const
operations_research::sat::PROTOBUF_FINAL::set_max_sat_reverse_assumption_order
void set_max_sat_reverse_assumption_order(bool value)
operations_research::sat::PROTOBUF_FINAL::exploit_integer_lp_solution
bool exploit_integer_lp_solution() const
operations_research::sat::PROTOBUF_FINAL::has_optimize_with_max_hs
bool has_optimize_with_max_hs() const
operations_research::sat::PROTOBUF_FINAL::clear_cover_optimization
void clear_cover_optimization()
operations_research::sat::PROTOBUF_FINAL::expand_table_constraints
bool expand_table_constraints() const
operations_research::sat::PROTOBUF_FINAL::clear_expand_element_constraints
void clear_expand_element_constraints()
operations_research::sat::PROTOBUF_FINAL::ClauseProtection
SatParameters_ClauseProtection ClauseProtection
Definition: sat_parameters.pb.h:601
operations_research::sat::PROTOBUF_FINAL::set_lns_focus_on_decision_variables
void set_lns_focus_on_decision_variables(bool value)
operations_research::sat::PROTOBUF_FINAL::new_constraints_batch_size
::PROTOBUF_NAMESPACE_ID::int32 new_constraints_batch_size() const
operations_research::sat::PROTOBUF_FINAL::set_variable_activity_decay
void set_variable_activity_decay(double value)
operations_research::sat::PROTOBUF_FINAL::set_presolve_blocked_clause
void set_presolve_blocked_clause(bool value)
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * ClauseOrdering_descriptor()
Definition: sat_parameters.pb.h:648
operations_research::sat::PROTOBUF_FINAL::has_max_sat_reverse_assumption_order
bool has_max_sat_reverse_assumption_order() const
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_lbd_bound
::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_lbd_bound() const
operations_research::sat::PROTOBUF_FINAL::set_random_seed
void set_random_seed(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::lns_expand_intervals_in_constraint_graph
bool lns_expand_intervals_in_constraint_graph() const
operations_research::sat::PROTOBUF_FINAL::clear_diversify_lns_params
void clear_diversify_lns_params()
operations_research::sat::PROTOBUF_FINAL::clear_presolve_extract_integer_enforcement
void clear_presolve_extract_integer_enforcement()
operations_research::sat::PROTOBUF_FINAL::set_use_implied_bounds
void set_use_implied_bounds(bool value)
operations_research::sat::PROTOBUF_FINAL::has_subsumption_during_conflict_analysis
bool has_subsumption_during_conflict_analysis() const
operations_research::sat::PROTOBUF_FINAL::clear_minimize_core
void clear_minimize_core()
operations_research::sat::PROTOBUF_FINAL::use_absl_random
bool use_absl_random() const
operations_research::sat::PROTOBUF_FINAL::glucose_decay_increment
double glucose_decay_increment() const
operations_research::sat::PROTOBUF_FINAL::use_timetable_edge_finding_in_cumulative_constraint
bool use_timetable_edge_finding_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::has_minimize_with_propagation_num_decisions
bool has_minimize_with_propagation_num_decisions() const
operations_research::sat::PROTOBUF_FINAL::clear_hint_conflict_limit
void clear_hint_conflict_limit()
operations_research::sat::PROTOBUF_FINAL::clear_treat_binary_clauses_separately
void clear_treat_binary_clauses_separately()
operations_research::sat::PROTOBUF_FINAL::has_enumerate_all_solutions
bool has_enumerate_all_solutions() const
operations_research::sat::PROTOBUF_FINAL::minimize_with_propagation_num_decisions
::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_num_decisions() const
operations_research::sat::PROTOBUF_FINAL::clear_log_search_progress
void clear_log_search_progress()
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm_IsValid
static bool RestartAlgorithm_IsValid(int value)
Definition: sat_parameters.pb.h:674
operations_research::sat::PROTOBUF_FINAL::has_permute_variable_randomly
bool has_permute_variable_randomly() const
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * MaxSatAssumptionOrder_descriptor()
Definition: sat_parameters.pb.h:716
operations_research::sat::PROTOBUF_FINAL::VariableOrder
SatParameters_VariableOrder VariableOrder
Definition: sat_parameters.pb.h:463
operations_research::sat::PROTOBUF_FINAL::cut_active_count_decay
double cut_active_count_decay() const
operations_research::sat::PROTOBUF_FINAL::clear_use_disjunctive_constraint_in_cumulative_constraint
void clear_use_disjunctive_constraint_in_cumulative_constraint()
operations_research::sat::PROTOBUF_FINAL::set_disable_constraint_expansion
void set_disable_constraint_expansion(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_add_cg_cuts
void clear_add_cg_cuts()
operations_research::sat::PROTOBUF_FINAL::clear_pb_cleanup_increment
void clear_pb_cleanup_increment()
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm_Name
static const std::string & BinaryMinizationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:590
operations_research::sat::PROTOBUF_FINAL::mutable_unknown_fields
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet * mutable_unknown_fields()
Definition: sat_parameters.pb.h:375
operations_research::sat::PROTOBUF_FINAL::add_cg_cuts
bool add_cg_cuts() const
operations_research::sat::PROTOBUF_FINAL::Swap
void Swap(SatParameters *other)
Definition: sat_parameters.pb.h:400
operations_research::sat::PROTOBUF_FINAL::mip_var_scaling
double mip_var_scaling() const
operations_research::sat::PROTOBUF_FINAL::set_probing_period_at_root
void set_probing_period_at_root(::PROTOBUF_NAMESPACE_ID::int64 value)
operations_research::sat::PROTOBUF_FINAL::clear_exploit_integer_lp_solution
void clear_exploit_integer_lp_solution()
operations_research::sat::PROTOBUF_FINAL::add_clique_cuts
bool add_clique_cuts() const
operations_research::sat::PROTOBUF_FINAL::clear_use_feasibility_pump
void clear_use_feasibility_pump()
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm
SatParameters_ConflictMinimizationAlgorithm ConflictMinimizationAlgorithm
Definition: sat_parameters.pb.h:531
operations_research::sat::PROTOBUF_FINAL::has_share_level_zero_bounds
bool has_share_level_zero_bounds() const
operations_research::sat::PROTOBUF_FINAL::max_number_of_conflicts
::PROTOBUF_NAMESPACE_ID::int64 max_number_of_conflicts() const
operations_research::sat::PROTOBUF_FINAL::instantiate_all_variables
bool instantiate_all_variables() const
operations_research::sat::PROTOBUF_FINAL::has_pb_cleanup_ratio
bool has_pb_cleanup_ratio() const
operations_research::sat::PROTOBUF_FINAL::set_instantiate_all_variables
void set_instantiate_all_variables(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_share_objective_bounds
void clear_share_objective_bounds()
operations_research::sat::PROTOBUF_FINAL::add_zero_half_cuts
bool add_zero_half_cuts() const
operations_research::sat::PROTOBUF_FINAL::clear_restart_running_window_size
void clear_restart_running_window_size()
operations_research::sat::PROTOBUF_FINAL::set_log_search_progress
void set_log_search_progress(bool value)
operations_research::sat::PROTOBUF_FINAL::has_relative_gap_limit
bool has_relative_gap_limit() const
operations_research::sat::PROTOBUF_FINAL::clear_restart_lbd_average_ratio
void clear_restart_lbd_average_ratio()
operations_research::sat::PROTOBUF_FINAL::clear_cut_max_active_count_value
void clear_cut_max_active_count_value()
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_period
void set_clause_cleanup_period(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::has_max_deterministic_time
bool has_max_deterministic_time() const
operations_research::sat::PROTOBUF_FINAL::has_expand_reservoir_constraints
bool has_expand_reservoir_constraints() const
operations_research::sat::PROTOBUF_FINAL::set_exploit_best_solution
void set_exploit_best_solution(bool value)
operations_research::sat::PROTOBUF_FINAL::set_symmetry_level
void set_symmetry_level(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::SearchBranching_IsValid
static bool SearchBranching_IsValid(int value)
Definition: sat_parameters.pb.h:778
operations_research::sat::PROTOBUF_FINAL::add_lp_constraints_lazily
bool add_lp_constraints_lazily() const
operations_research::sat::PROTOBUF_FINAL::clear_max_sat_reverse_assumption_order
void clear_max_sat_reverse_assumption_order()
operations_research::sat::PROTOBUF_FINAL::clear_use_phase_saving
void clear_use_phase_saving()
operations_research::sat::PROTOBUF_FINAL::set_cut_max_active_count_value
void set_cut_max_active_count_value(double value)
operations_research::sat::PROTOBUF_FINAL::set_exploit_relaxation_solution
void set_exploit_relaxation_solution(bool value)
operations_research::sat::PROTOBUF_FINAL::presolve_extract_integer_enforcement
bool presolve_extract_integer_enforcement() const
operations_research::sat::PROTOBUF_FINAL::auto_detect_greater_than_at_least_one_of
bool auto_detect_greater_than_at_least_one_of() const
operations_research::sat::PROTOBUF_FINAL::has_stop_after_presolve
bool has_stop_after_presolve() const
operations_research::sat::PROTOBUF_FINAL::clear_presolve_use_bva
void clear_presolve_use_bva()
operations_research::sat::PROTOBUF_FINAL::set_keep_all_feasible_solutions_in_presolve
void set_keep_all_feasible_solutions_in_presolve(bool value)
operations_research::sat::PROTOBUF_FINAL::random_seed
::PROTOBUF_NAMESPACE_ID::int32 random_seed() const
operations_research::sat::PROTOBUF_FINAL::clear_use_probing_search
void clear_use_probing_search()
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_lbd_bound
void set_clause_cleanup_lbd_bound(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::set_binary_minimization_algorithm
void set_binary_minimization_algorithm(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::has_absolute_gap_limit
bool has_absolute_gap_limit() const
operations_research::sat::PROTOBUF_FINAL::clear_mip_max_activity_exponent
void clear_mip_max_activity_exponent()
operations_research::sat::PROTOBUF_FINAL::clear_relative_gap_limit
void clear_relative_gap_limit()
operations_research::sat::PROTOBUF_FINAL::has_interleave_batch_size
bool has_interleave_batch_size() const
operations_research::sat::PROTOBUF_FINAL::has_use_combined_no_overlap
bool has_use_combined_no_overlap() const
operations_research::sat::PROTOBUF_FINAL::has_search_randomization_tolerance
bool has_search_randomization_tolerance() const
operations_research::sat::PROTOBUF_FINAL::clear_max_time_in_seconds
void clear_max_time_in_seconds()
operations_research::sat::PROTOBUF_FINAL::clear_fill_logs_in_response
void clear_fill_logs_in_response()
operations_research::sat::PROTOBUF_FINAL::has_glucose_max_decay
bool has_glucose_max_decay() const
operations_research::sat::PROTOBUF_FINAL::absolute_gap_limit
double absolute_gap_limit() const
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder_Name
static const std::string & MaxSatAssumptionOrder_Name(T enum_t_value)
Definition: sat_parameters.pb.h:720
operations_research::sat::PROTOBUF_FINAL::pseudo_cost_reliability_threshold
::PROTOBUF_NAMESPACE_ID::int64 pseudo_cost_reliability_threshold() const
operations_research::sat::PROTOBUF_FINAL::use_exact_lp_reason
bool use_exact_lp_reason() const
operations_research::sat::PROTOBUF_FINAL::MaxSatStratificationAlgorithm_Parse
static bool MaxSatStratificationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MaxSatStratificationAlgorithm *value)
Definition: sat_parameters.pb.h:758
operations_research::sat::PROTOBUF_FINAL::New
SatParameters * New() const final
Definition: sat_parameters.pb.h:416
operations_research::sat::PROTOBUF_FINAL::clear_stop_after_first_solution
void clear_stop_after_first_solution()
operations_research::sat::PROTOBUF_FINAL::clear_add_knapsack_cuts
void clear_add_knapsack_cuts()
operations_research::sat::PROTOBUF_FINAL::set_expand_reservoir_constraints
void set_expand_reservoir_constraints(bool value)
operations_research::sat::PROTOBUF_FINAL::set_hint_conflict_limit
void set_hint_conflict_limit(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::GetMetadata
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final
operations_research::sat::PROTOBUF_FINAL::has_use_lns_only
bool has_use_lns_only() const
operations_research::sat::PROTOBUF_FINAL::use_probing_search
bool use_probing_search() const
operations_research::sat::PROTOBUF_FINAL::clear_fill_tightened_domains_in_response
void clear_fill_tightened_domains_in_response()
operations_research::sat::PROTOBUF_FINAL::clear_presolve_substitution_level
void clear_presolve_substitution_level()
operations_research::sat::PROTOBUF_FINAL::has_max_sat_stratification
bool has_max_sat_stratification() const
operations_research::sat::PROTOBUF_FINAL::has_minimize_core
bool has_minimize_core() const
operations_research::sat::PROTOBUF_FINAL::clear_fp_rounding
void clear_fp_rounding()
operations_research::sat::PROTOBUF_FINAL::has_presolve_use_bva
bool has_presolve_use_bva() const
operations_research::sat::PROTOBUF_FINAL::set_presolve_bve_clause_weight
void set_presolve_bve_clause_weight(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::stop_after_presolve
bool stop_after_presolve() const
operations_research::sat::PROTOBUF_FINAL::SatParameters
SatParameters(const SatParameters &from)
operations_research::sat::PROTOBUF_FINAL::set_lns_expand_intervals_in_constraint_graph
void set_lns_expand_intervals_in_constraint_graph(bool value)
operations_research::sat::PROTOBUF_FINAL::max_time_in_seconds
double max_time_in_seconds() const
operations_research::sat::PROTOBUF_FINAL::GetDescriptor
static const ::PROTOBUF_NAMESPACE_ID::Descriptor * GetDescriptor()
Definition: sat_parameters.pb.h:382
operations_research::sat::PROTOBUF_FINAL::has_initial_polarity
bool has_initial_polarity() const
operations_research::sat::PROTOBUF_FINAL::set_convert_intervals
void set_convert_intervals(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_repair_hint
void clear_repair_hint()
operations_research::sat::PROTOBUF_FINAL::binary_search_num_conflicts
::PROTOBUF_NAMESPACE_ID::int32 binary_search_num_conflicts() const
operations_research::sat::PROTOBUF_FINAL::set_add_zero_half_cuts
void set_add_zero_half_cuts(bool value)
operations_research::sat::PROTOBUF_FINAL::restart_algorithms
const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int > & restart_algorithms() const
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_postsolve_with_full_solver
void clear_cp_model_postsolve_with_full_solver()
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_use_sat_presolve
void clear_cp_model_use_sat_presolve()
operations_research::sat::PROTOBUF_FINAL::set_restart_running_window_size
void set_restart_running_window_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_period
::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_period() const
operations_research::sat::PROTOBUF_FINAL::set_use_probing_search
void set_use_probing_search(bool value)
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm_Parse
static bool RestartAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RestartAlgorithm *value)
Definition: sat_parameters.pb.h:694
operations_research::sat::PROTOBUF_FINAL::set_exploit_integer_lp_solution
void set_exploit_integer_lp_solution(bool value)
operations_research::sat::PROTOBUF_FINAL::max_integer_rounding_scaling
::PROTOBUF_NAMESPACE_ID::int32 max_integer_rounding_scaling() const
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm
SatParameters_RestartAlgorithm RestartAlgorithm
Definition: sat_parameters.pb.h:663
operations_research::sat::PROTOBUF_FINAL::RestartAlgorithm_Name
static const std::string & RestartAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:688
operations_research::sat::PROTOBUF_FINAL::set_presolve_use_bva
void set_presolve_use_bva(bool value)
operations_research::sat::PROTOBUF_FINAL::use_blocking_restart
bool use_blocking_restart() const
operations_research::sat::PROTOBUF_FINAL::initial_variables_activity
double initial_variables_activity() const
operations_research::sat::PROTOBUF_FINAL::mip_max_bound
double mip_max_bound() const
operations_research::sat::PROTOBUF_FINAL::clear_add_clique_cuts
void clear_add_clique_cuts()
operations_research::sat::PROTOBUF_FINAL::clear_restart_period
void clear_restart_period()
operations_research::sat::PROTOBUF_FINAL::set_merge_no_overlap_work_limit
void set_merge_no_overlap_work_limit(double value)
operations_research::sat::PROTOBUF_FINAL::clear_add_lp_constraints_lazily
void clear_add_lp_constraints_lazily()
operations_research::sat::PROTOBUF_FINAL::clear_random_polarity_ratio
void clear_random_polarity_ratio()
operations_research::sat::PROTOBUF_FINAL::random_branches_ratio
double random_branches_ratio() const
operations_research::sat::PROTOBUF_FINAL::has_use_overload_checker_in_cumulative_constraint
bool has_use_overload_checker_in_cumulative_constraint() const
operations_research::sat::PROTOBUF_FINAL::clear_max_memory_in_mb
void clear_max_memory_in_mb()
operations_research::sat::PROTOBUF_FINAL::has_count_assumption_levels_in_lbd
bool has_count_assumption_levels_in_lbd() const
operations_research::sat::PROTOBUF_FINAL::ConflictMinimizationAlgorithm_Name
static const std::string & ConflictMinimizationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:554
operations_research::sat::PROTOBUF_FINAL::search_randomization_tolerance
::PROTOBUF_NAMESPACE_ID::int64 search_randomization_tolerance() const
operations_research::sat::PROTOBUF_FINAL::has_symmetry_level
bool has_symmetry_level() const
operations_research::sat::PROTOBUF_FINAL::clear_random_branches_ratio
void clear_random_branches_ratio()
operations_research::sat::PROTOBUF_FINAL::set_add_cg_cuts
void set_add_cg_cuts(bool value)
operations_research::sat::PROTOBUF_FINAL::pb_cleanup_ratio
double pb_cleanup_ratio() const
operations_research::sat::PROTOBUF_FINAL::has_mip_max_activity_exponent
bool has_mip_max_activity_exponent() const
operations_research::sat::PROTOBUF_FINAL::clear_mip_var_scaling
void clear_mip_var_scaling()
operations_research::sat::PROTOBUF_FINAL::has_log_search_progress
bool has_log_search_progress() const
operations_research::sat::PROTOBUF_FINAL::FPRoundingMethod_Parse
static bool FPRoundingMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FPRoundingMethod *value)
Definition: sat_parameters.pb.h:832
operations_research::sat::PROTOBUF_FINAL::clear_probing_period_at_root
void clear_probing_period_at_root()
operations_research::sat::PROTOBUF_FINAL::SearchBranching_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SearchBranching_descriptor()
Definition: sat_parameters.pb.h:788
operations_research::sat::PROTOBUF_FINAL::exploit_objective
bool exploit_objective() const
operations_research::sat::PROTOBUF_FINAL::presolve_use_bva
bool presolve_use_bva() const
operations_research::sat::PROTOBUF_FINAL::clear_blocking_restart_window_size
void clear_blocking_restart_window_size()
operations_research::sat::PROTOBUF_FINAL::set_add_lin_max_cuts
void set_add_lin_max_cuts(bool value)
operations_research::sat::PROTOBUF_FINAL::has_fill_tightened_domains_in_response
bool has_fill_tightened_domains_in_response() const
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm_IsValid
static bool BinaryMinizationAlgorithm_IsValid(int value)
Definition: sat_parameters.pb.h:576
operations_research::sat::PROTOBUF_FINAL::has_randomize_search
bool has_randomize_search() const
operations_research::sat::PROTOBUF_FINAL::restart_algorithms_size
int restart_algorithms_size() const
operations_research::sat::PROTOBUF_FINAL::has_cut_max_active_count_value
bool has_cut_max_active_count_value() const
operations_research::sat::PROTOBUF_FINAL::blocking_restart_window_size
::PROTOBUF_NAMESPACE_ID::int32 blocking_restart_window_size() const
operations_research::sat::PROTOBUF_FINAL::glucose_decay_increment_period
::PROTOBUF_NAMESPACE_ID::int32 glucose_decay_increment_period() const
operations_research::sat::PROTOBUF_FINAL::set_max_time_in_seconds
void set_max_time_in_seconds(double value)
operations_research::sat::PROTOBUF_FINAL::has_use_probing_search
bool has_use_probing_search() const
operations_research::sat::PROTOBUF_FINAL::has_polarity_rephase_increment
bool has_polarity_rephase_increment() const
operations_research::sat::PROTOBUF_FINAL::name
const std::string & name() const
operations_research::sat::PROTOBUF_FINAL::set_count_assumption_levels_in_lbd
void set_count_assumption_levels_in_lbd(bool value)
operations_research::sat::PROTOBUF_FINAL::has_use_precedences_in_disjunctive_constraint
bool has_use_precedences_in_disjunctive_constraint() const
operations_research::sat::PROTOBUF_FINAL::binary_minimization_algorithm
::operations_research::sat::SatParameters_BinaryMinizationAlgorithm binary_minimization_algorithm() const
operations_research::sat::PROTOBUF_FINAL::set_cut_cleanup_target
void set_cut_cleanup_target(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_search_randomization_tolerance
void clear_search_randomization_tolerance()
operations_research::sat::PROTOBUF_FINAL::MaxSatAssumptionOrder
SatParameters_MaxSatAssumptionOrder MaxSatAssumptionOrder
Definition: sat_parameters.pb.h:699
operations_research::sat::PROTOBUF_FINAL::has_clause_activity_decay
bool has_clause_activity_decay() const
operations_research::sat::PROTOBUF_FINAL::internal_default_instance
static const SatParameters * internal_default_instance()
Definition: sat_parameters.pb.h:390
operations_research::sat::PROTOBUF_FINAL::set_initial_variables_activity
void set_initial_variables_activity(double value)
operations_research::sat::PROTOBUF_FINAL::clear_subsumption_during_conflict_analysis
void clear_subsumption_during_conflict_analysis()
operations_research::sat::PROTOBUF_FINAL::clear_minimize_with_propagation_restart_period
void clear_minimize_with_propagation_restart_period()
operations_research::sat::PROTOBUF_FINAL::clear_use_overload_checker_in_cumulative_constraint
void clear_use_overload_checker_in_cumulative_constraint()
operations_research::sat::PROTOBUF_FINAL::has_mip_check_precision
bool has_mip_check_precision() const
operations_research::sat::PROTOBUF_FINAL::set_name
void set_name(const char *value)
operations_research::sat::PROTOBUF_FINAL::set_name
void set_name(std::string &&value)
operations_research::sat::PROTOBUF_FINAL::min_orthogonality_for_lp_constraints
double min_orthogonality_for_lp_constraints() const
operations_research::sat::PROTOBUF_FINAL::random_polarity_ratio
double random_polarity_ratio() const
operations_research::sat::PROTOBUF_FINAL::boolean_encoding_level
::PROTOBUF_NAMESPACE_ID::int32 boolean_encoding_level() const
operations_research::sat::PROTOBUF_FINAL::has_use_exact_lp_reason
bool has_use_exact_lp_reason() const
operations_research::sat::PROTOBUF_FINAL::BinaryMinizationAlgorithm_descriptor
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * BinaryMinizationAlgorithm_descriptor()
Definition: sat_parameters.pb.h:586
operations_research::sat::PROTOBUF_FINAL::max_sat_reverse_assumption_order
bool max_sat_reverse_assumption_order() const
operations_research::sat::PROTOBUF_FINAL::set_use_combined_no_overlap
void set_use_combined_no_overlap(bool value)
operations_research::sat::PROTOBUF_FINAL::has_use_sat_inprocessing
bool has_use_sat_inprocessing() const
operations_research::sat::PROTOBUF_FINAL::has_expand_automaton_constraints
bool has_expand_automaton_constraints() const
operations_research::sat::PROTOBUF_FINAL::has_presolve_blocked_clause
bool has_presolve_blocked_clause() const
operations_research::sat::PROTOBUF_FINAL::set_expand_table_constraints
void set_expand_table_constraints(bool value)
operations_research::sat::PROTOBUF_FINAL::set_use_pb_resolution
void set_use_pb_resolution(bool value)
operations_research::sat::PROTOBUF_FINAL::set_default_restart_algorithms
void set_default_restart_algorithms(std::string &&value)
operations_research::sat::PROTOBUF_FINAL::set_use_phase_saving
void set_use_phase_saving(bool value)
operations_research::sat::PROTOBUF_FINAL::optimize_with_max_hs
bool optimize_with_max_hs() const
operations_research::sat::PROTOBUF_FINAL::has_lns_expand_intervals_in_constraint_graph
bool has_lns_expand_intervals_in_constraint_graph() const
operations_research::sat::PROTOBUF_FINAL::set_fp_rounding
void set_fp_rounding(::operations_research::sat::SatParameters_FPRoundingMethod value)
operations_research::sat::PROTOBUF_FINAL::cp_model_max_num_presolve_operations
::PROTOBUF_NAMESPACE_ID::int32 cp_model_max_num_presolve_operations() const
operations_research::sat::PROTOBUF_FINAL::set_use_erwa_heuristic
void set_use_erwa_heuristic(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_use_optimization_hints
void clear_use_optimization_hints()
operations_research::sat::PROTOBUF_FINAL::has_max_all_diff_cut_size
bool has_max_all_diff_cut_size() const
operations_research::sat::PROTOBUF_FINAL::minimize_with_propagation_restart_period
::PROTOBUF_NAMESPACE_ID::int32 minimize_with_propagation_restart_period() const
operations_research::sat::PROTOBUF_FINAL::randomize_search
bool randomize_search() const
operations_research::sat::PROTOBUF_FINAL::ClauseProtection_Parse
static bool ClauseProtection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClauseProtection *value)
Definition: sat_parameters.pb.h:628
operations_research::sat::PROTOBUF_FINAL::set_max_sat_stratification
void set_max_sat_stratification(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm value)
operations_research::sat::PROTOBUF_FINAL::clear_convert_intervals
void clear_convert_intervals()
operations_research::sat::PROTOBUF_FINAL::cut_cleanup_target
::PROTOBUF_NAMESPACE_ID::int32 cut_cleanup_target() const
operations_research::sat::PROTOBUF_FINAL::clear_boolean_encoding_level
void clear_boolean_encoding_level()
operations_research::sat::PROTOBUF_FINAL::has_use_rins_lns
bool has_use_rins_lns() const
operations_research::sat::PROTOBUF_FINAL::cp_model_postsolve_with_full_solver
bool cp_model_postsolve_with_full_solver() const
operations_research::sat::PROTOBUF_FINAL::permute_variable_randomly
bool permute_variable_randomly() const
operations_research::sat::PROTOBUF_FINAL::clear_restart_dl_average_ratio
void clear_restart_dl_average_ratio()
operations_research::sat::PROTOBUF_FINAL::clear_max_presolve_iterations
void clear_max_presolve_iterations()
operations_research::sat::PROTOBUF_FINAL::clear_presolve_bva_threshold
void clear_presolve_bva_threshold()
operations_research::sat::PROTOBUF_FINAL::clear_instantiate_all_variables
void clear_instantiate_all_variables()
operations_research::sat::PROTOBUF_FINAL::max_cut_rounds_at_level_zero
::PROTOBUF_NAMESPACE_ID::int32 max_cut_rounds_at_level_zero() const
operations_research::sat::PROTOBUF_FINAL::clear_pb_cleanup_ratio
void clear_pb_cleanup_ratio()
operations_research::sat::PROTOBUF_FINAL::set_allocated_name
void set_allocated_name(std::string *name)
operations_research::sat::PROTOBUF_FINAL::set_presolve_extract_integer_enforcement
void set_presolve_extract_integer_enforcement(bool value)
operations_research::sat::PROTOBUF_FINAL::set_add_knapsack_cuts
void set_add_knapsack_cuts(bool value)
operations_research::sat::PROTOBUF_FINAL::has_max_sat_assumption_order
bool has_max_sat_assumption_order() const
operations_research::sat::PROTOBUF_FINAL::has_pb_cleanup_increment
bool has_pb_cleanup_increment() const
operations_research::sat::PROTOBUF_FINAL::only_add_cuts_at_level_zero
bool only_add_cuts_at_level_zero() const
operations_research::sat::PROTOBUF_FINAL::has_random_polarity_ratio
bool has_random_polarity_ratio() const
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering
SatParameters_ClauseOrdering ClauseOrdering
Definition: sat_parameters.pb.h:633
operations_research::sat::PROTOBUF_FINAL::clear_absolute_gap_limit
void clear_absolute_gap_limit()
operations_research::sat::PROTOBUF_FINAL::set_use_optional_variables
void set_use_optional_variables(bool value)
operations_research::sat::PROTOBUF_FINAL::has_add_zero_half_cuts
bool has_add_zero_half_cuts() const
operations_research::sat::PROTOBUF_FINAL::exploit_relaxation_solution
bool exploit_relaxation_solution() const
operations_research::sat::PROTOBUF_FINAL::has_mip_automatically_scale_variables
bool has_mip_automatically_scale_variables() const
operations_research::sat::PROTOBUF_FINAL::set_subsumption_during_conflict_analysis
void set_subsumption_during_conflict_analysis(bool value)
operations_research::sat::PROTOBUF_FINAL::has_mip_max_bound
bool has_mip_max_bound() const
operations_research::sat::PROTOBUF_FINAL::has_add_mir_cuts
bool has_add_mir_cuts() const
operations_research::sat::PROTOBUF_FINAL::set_mip_max_bound
void set_mip_max_bound(double value)
operations_research::sat::PROTOBUF_FINAL::clear_permute_presolve_constraint_order
void clear_permute_presolve_constraint_order()
operations_research::sat::PROTOBUF_FINAL::clear_symmetry_level
void clear_symmetry_level()
operations_research::sat::PROTOBUF_FINAL::set_allocated_default_restart_algorithms
void set_allocated_default_restart_algorithms(std::string *default_restart_algorithms)
operations_research::sat::PROTOBUF_FINAL::clear_use_erwa_heuristic
void clear_use_erwa_heuristic()
operations_research::sat::PROTOBUF_FINAL::probing_period_at_root
::PROTOBUF_NAMESPACE_ID::int64 probing_period_at_root() const
operations_research::sat::PROTOBUF_FINAL::default_instance
static const SatParameters & default_instance()
operations_research::sat::PROTOBUF_FINAL::clear_enumerate_all_solutions
void clear_enumerate_all_solutions()
operations_research::sat::PROTOBUF_FINAL::clear_interleave_search
void clear_interleave_search()
operations_research::sat::PROTOBUF_FINAL::use_optional_variables
bool use_optional_variables() const
operations_research::sat::PROTOBUF_FINAL::ClauseOrdering_Name
static const std::string & ClauseOrdering_Name(T enum_t_value)
Definition: sat_parameters.pb.h:652
operations_research::sat::PROTOBUF_FINAL::clause_cleanup_target
::PROTOBUF_NAMESPACE_ID::int32 clause_cleanup_target() const
operations_research::sat::PROTOBUF_FINAL::set_default_restart_algorithms
void set_default_restart_algorithms(const std::string &value)
operations_research::sat::PROTOBUF_FINAL::clear_cut_active_count_decay
void clear_cut_active_count_decay()
operations_research::sat::PROTOBUF_FINAL::set_presolve_probing_deterministic_time_limit
void set_presolve_probing_deterministic_time_limit(double value)
operations_research::sat::PROTOBUF_FINAL::set_cp_model_use_sat_presolve
void set_cp_model_use_sat_presolve(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_cp_model_max_num_presolve_operations
void clear_cp_model_max_num_presolve_operations()
operations_research::sat::PROTOBUF_FINAL::has_cut_cleanup_target
bool has_cut_cleanup_target() const
operations_research::sat::PROTOBUF_FINAL::clear_glucose_decay_increment
void clear_glucose_decay_increment()
operations_research::sat::PROTOBUF_FINAL::disable_constraint_expansion
bool disable_constraint_expansion() const
operations_research::sat::PROTOBUF_FINAL::set_num_conflicts_before_strategy_changes
void set_num_conflicts_before_strategy_changes(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::presolve_bva_threshold
::PROTOBUF_NAMESPACE_ID::int32 presolve_bva_threshold() const
operations_research::sat::PROTOBUF_FINAL::set_max_all_diff_cut_size
void set_max_all_diff_cut_size(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::hint_conflict_limit
::PROTOBUF_NAMESPACE_ID::int32 hint_conflict_limit() const
operations_research::sat::PROTOBUF_FINAL::max_presolve_iterations
::PROTOBUF_NAMESPACE_ID::int32 max_presolve_iterations() const
operations_research::sat::PROTOBUF_FINAL::unknown_fields
const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet & unknown_fields() const
Definition: sat_parameters.pb.h:372
operations_research::sat::PROTOBUF_FINAL::VariableOrder_Parse
static bool VariableOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VariableOrder *value)
Definition: sat_parameters.pb.h:490
operations_research::sat::PROTOBUF_FINAL::clear_min_orthogonality_for_lp_constraints
void clear_min_orthogonality_for_lp_constraints()
operations_research::sat::PROTOBUF_FINAL::set_glucose_decay_increment_period
void set_glucose_decay_increment_period(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::set_fill_logs_in_response
void set_fill_logs_in_response(bool value)
operations_research::sat::PROTOBUF_FINAL::set_share_objective_bounds
void set_share_objective_bounds(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_search_branching
void clear_search_branching()
operations_research::sat::PROTOBUF_FINAL::add_knapsack_cuts
bool add_knapsack_cuts() const
operations_research::sat::PROTOBUF_FINAL::set_max_consecutive_inactive_count
void set_max_consecutive_inactive_count(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::share_level_zero_bounds
bool share_level_zero_bounds() const
operations_research::sat::PROTOBUF_FINAL::clear_num_conflicts_before_strategy_changes
void clear_num_conflicts_before_strategy_changes()
operations_research::sat::PROTOBUF_FINAL::max_sat_assumption_order
::operations_research::sat::SatParameters_MaxSatAssumptionOrder max_sat_assumption_order() const
operations_research::sat::PROTOBUF_FINAL::restart_dl_average_ratio
double restart_dl_average_ratio() const
operations_research::sat::PROTOBUF_FINAL::clear_minimize_with_propagation_num_decisions
void clear_minimize_with_propagation_num_decisions()
operations_research::sat::PROTOBUF_FINAL::has_expand_element_constraints
bool has_expand_element_constraints() const
operations_research::sat::PROTOBUF_FINAL::clear_interleave_batch_size
void clear_interleave_batch_size()
operations_research::sat::PROTOBUF_FINAL::restart_algorithms
::operations_research::sat::SatParameters_RestartAlgorithm restart_algorithms(int index) const
operations_research::sat::PROTOBUF_FINAL::set_absolute_gap_limit
void set_absolute_gap_limit(double value)
operations_research::sat::PROTOBUF_FINAL::set_num_search_workers
void set_num_search_workers(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::set_share_level_zero_bounds
void set_share_level_zero_bounds(bool value)
operations_research::sat::PROTOBUF_FINAL::clear_disable_constraint_expansion
void clear_disable_constraint_expansion()
operations_research::sat::PROTOBUF_FINAL::has_use_optimization_hints
bool has_use_optimization_hints() const
operations_research::sat::PROTOBUF_FINAL::clear_minimize_reduction_during_pb_resolution
void clear_minimize_reduction_during_pb_resolution()
operations_research::sat::PROTOBUF_FINAL::set_clause_cleanup_protection
void set_clause_cleanup_protection(::operations_research::sat::SatParameters_ClauseProtection value)
operations_research::sat::PROTOBUF_FINAL::clear_permute_variable_randomly
void clear_permute_variable_randomly()
operations_research::sat::PROTOBUF_FINAL::has_add_lp_constraints_lazily
bool has_add_lp_constraints_lazily() const
operations_research::sat::PROTOBUF_FINAL::set_max_cut_rounds_at_level_zero
void set_max_cut_rounds_at_level_zero(::PROTOBUF_NAMESPACE_ID::int32 value)
operations_research::sat::PROTOBUF_FINAL::clear_polarity_rephase_increment
void clear_polarity_rephase_increment()
operations_research::sat::PROTOBUF_FINAL::diversify_lns_params
bool diversify_lns_params() const
operations_research::sat::PROTOBUF_FINAL::has_strategy_change_increase_ratio
bool has_strategy_change_increase_ratio() const
operations_research::sat::PROTOBUF_FINAL::count_assumption_levels_in_lbd
bool count_assumption_levels_in_lbd() const
operations_research::sat::SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE
constexpr int SatParameters_ClauseOrdering_ClauseOrdering_ARRAYSIZE
Definition: sat_parameters.pb.h:202
operations_research::sat::SatParameters_ClauseOrdering_ClauseOrdering_MIN
constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MIN
Definition: sat_parameters.pb.h:200
operations_research::sat::SatParameters_SearchBranching_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_SearchBranching_descriptor()
operations_research::sat::SatParameters_ClauseProtection_ClauseProtection_MAX
constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MAX
Definition: sat_parameters.pb.h:178
operations_research::sat::SatParameters_VariableOrder_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_VariableOrder_descriptor()
operations_research::sat::SatParameters_RestartAlgorithm_Parse
bool SatParameters_RestartAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_RestartAlgorithm *value)
Definition: sat_parameters.pb.h:239
operations_research::sat::SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE
constexpr int SatParameters_ClauseProtection_ClauseProtection_ARRAYSIZE
Definition: sat_parameters.pb.h:179
operations_research::sat::SatParameters_Polarity_Parse
bool SatParameters_Polarity_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_Polarity *value)
Definition: sat_parameters.pb.h:115
operations_research::sat::SatParameters_SearchBranching
SatParameters_SearchBranching
Definition: sat_parameters.pb.h:292
operations_research::sat::SatParameters_SearchBranching_PORTFOLIO_SEARCH
@ SatParameters_SearchBranching_PORTFOLIO_SEARCH
Definition: sat_parameters.pb.h:295
operations_research::sat::SatParameters_SearchBranching_HINT_SEARCH
@ SatParameters_SearchBranching_HINT_SEARCH
Definition: sat_parameters.pb.h:299
operations_research::sat::SatParameters_SearchBranching_PSEUDO_COST_SEARCH
@ SatParameters_SearchBranching_PSEUDO_COST_SEARCH
Definition: sat_parameters.pb.h:297
operations_research::sat::SatParameters_SearchBranching_FIXED_SEARCH
@ SatParameters_SearchBranching_FIXED_SEARCH
Definition: sat_parameters.pb.h:294
operations_research::sat::SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH
@ SatParameters_SearchBranching_PORTFOLIO_WITH_QUICK_RESTART_SEARCH
Definition: sat_parameters.pb.h:298
operations_research::sat::SatParameters_SearchBranching_AUTOMATIC_SEARCH
@ SatParameters_SearchBranching_AUTOMATIC_SEARCH
Definition: sat_parameters.pb.h:293
operations_research::sat::SatParameters_SearchBranching_LP_SEARCH
@ SatParameters_SearchBranching_LP_SEARCH
Definition: sat_parameters.pb.h:296
operations_research::sat::SatParameters_FPRoundingMethod
SatParameters_FPRoundingMethod
Definition: sat_parameters.pb.h:320
operations_research::sat::SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED
@ SatParameters_FPRoundingMethod_ACTIVE_LOCK_BASED
Definition: sat_parameters.pb.h:323
operations_research::sat::SatParameters_FPRoundingMethod_NEAREST_INTEGER
@ SatParameters_FPRoundingMethod_NEAREST_INTEGER
Definition: sat_parameters.pb.h:321
operations_research::sat::SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED
@ SatParameters_FPRoundingMethod_PROPAGATION_ASSISTED
Definition: sat_parameters.pb.h:324
operations_research::sat::SatParameters_FPRoundingMethod_LOCK_BASED
@ SatParameters_FPRoundingMethod_LOCK_BASED
Definition: sat_parameters.pb.h:322
operations_research::sat::SatParameters_ClauseProtection_Parse
bool SatParameters_ClauseProtection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ClauseProtection *value)
Definition: sat_parameters.pb.h:190
operations_research::sat::_SatParameters_default_instance_
SatParametersDefaultTypeInternal _SatParameters_default_instance_
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_Parse
bool SatParameters_MaxSatStratificationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_MaxSatStratificationAlgorithm *value)
Definition: sat_parameters.pb.h:287
operations_research::sat::SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX
constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MAX
Definition: sat_parameters.pb.h:251
operations_research::sat::SatParameters_FPRoundingMethod_Name
const std::string & SatParameters_FPRoundingMethod_Name(T enum_t_value)
Definition: sat_parameters.pb.h:333
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm
SatParameters_ConflictMinimizationAlgorithm
Definition: sat_parameters.pb.h:120
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_SIMPLE
@ SatParameters_ConflictMinimizationAlgorithm_SIMPLE
Definition: sat_parameters.pb.h:122
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL
@ SatParameters_ConflictMinimizationAlgorithm_EXPERIMENTAL
Definition: sat_parameters.pb.h:124
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_NONE
@ SatParameters_ConflictMinimizationAlgorithm_NONE
Definition: sat_parameters.pb.h:121
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_RECURSIVE
@ SatParameters_ConflictMinimizationAlgorithm_RECURSIVE
Definition: sat_parameters.pb.h:123
operations_research::sat::SatParameters_ClauseProtection_ClauseProtection_MIN
constexpr SatParameters_ClauseProtection SatParameters_ClauseProtection_ClauseProtection_MIN
Definition: sat_parameters.pb.h:177
operations_research::sat::SatParameters_FPRoundingMethod_IsValid
bool SatParameters_FPRoundingMethod_IsValid(int value)
operations_research::sat::SatParameters_SearchBranching_SearchBranching_ARRAYSIZE
constexpr int SatParameters_SearchBranching_SearchBranching_ARRAYSIZE
Definition: sat_parameters.pb.h:304
operations_research::sat::SatParameters_RestartAlgorithm_Name
const std::string & SatParameters_RestartAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:232
operations_research::sat::SatParameters_Polarity_Polarity_MAX
constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MAX
Definition: sat_parameters.pb.h:103
operations_research::sat::SatParameters_ClauseOrdering
SatParameters_ClauseOrdering
Definition: sat_parameters.pb.h:195
operations_research::sat::SatParameters_ClauseOrdering_CLAUSE_LBD
@ SatParameters_ClauseOrdering_CLAUSE_LBD
Definition: sat_parameters.pb.h:197
operations_research::sat::SatParameters_ClauseOrdering_CLAUSE_ACTIVITY
@ SatParameters_ClauseOrdering_CLAUSE_ACTIVITY
Definition: sat_parameters.pb.h:196
operations_research::sat::SatParameters_Polarity_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_Polarity_descriptor()
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_IsValid
bool SatParameters_BinaryMinizationAlgorithm_IsValid(int value)
operations_research::sat::SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE
constexpr int SatParameters_RestartAlgorithm_RestartAlgorithm_ARRAYSIZE
Definition: sat_parameters.pb.h:228
operations_research::sat::SatParameters_MaxSatAssumptionOrder_IsValid
bool SatParameters_MaxSatAssumptionOrder_IsValid(int value)
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MAX
Definition: sat_parameters.pb.h:154
operations_research::sat::SatParameters_VariableOrder_VariableOrder_MIN
constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MIN
Definition: sat_parameters.pb.h:76
operations_research::sat::SatParameters_Polarity_IsValid
bool SatParameters_Polarity_IsValid(int value)
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_Parse
bool SatParameters_BinaryMinizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_BinaryMinizationAlgorithm *value)
Definition: sat_parameters.pb.h:166
operations_research::sat::SatParameters_VariableOrder_VariableOrder_MAX
constexpr SatParameters_VariableOrder SatParameters_VariableOrder_VariableOrder_MAX
Definition: sat_parameters.pb.h:77
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MIN
Definition: sat_parameters.pb.h:127
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_IsValid
bool SatParameters_MaxSatStratificationAlgorithm_IsValid(int value)
operations_research::sat::SatParameters_ClauseOrdering_Parse
bool SatParameters_ClauseOrdering_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ClauseOrdering *value)
Definition: sat_parameters.pb.h:213
operations_research::sat::SatParameters_Polarity_Polarity_MIN
constexpr SatParameters_Polarity SatParameters_Polarity_Polarity_MIN
Definition: sat_parameters.pb.h:102
operations_research::sat::SatParameters_ClauseOrdering_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_ClauseOrdering_descriptor()
operations_research::sat::SatParameters_VariableOrder_IsValid
bool SatParameters_VariableOrder_IsValid(int value)
operations_research::sat::SatParameters_VariableOrder
SatParameters_VariableOrder
Definition: sat_parameters.pb.h:70
operations_research::sat::SatParameters_VariableOrder_IN_RANDOM_ORDER
@ SatParameters_VariableOrder_IN_RANDOM_ORDER
Definition: sat_parameters.pb.h:73
operations_research::sat::SatParameters_VariableOrder_IN_ORDER
@ SatParameters_VariableOrder_IN_ORDER
Definition: sat_parameters.pb.h:71
operations_research::sat::SatParameters_VariableOrder_IN_REVERSE_ORDER
@ SatParameters_VariableOrder_IN_REVERSE_ORDER
Definition: sat_parameters.pb.h:72
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_Name
const std::string & SatParameters_MaxSatStratificationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:280
operations_research::sat::SatParameters_BinaryMinizationAlgorithm
SatParameters_BinaryMinizationAlgorithm
Definition: sat_parameters.pb.h:145
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION
@ SatParameters_BinaryMinizationAlgorithm_EXPERIMENTAL_BINARY_MINIMIZATION
Definition: sat_parameters.pb.h:150
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION
@ SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION
Definition: sat_parameters.pb.h:148
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY
@ SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_WITH_REACHABILITY
Definition: sat_parameters.pb.h:149
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST
@ SatParameters_BinaryMinizationAlgorithm_BINARY_MINIMIZATION_FIRST
Definition: sat_parameters.pb.h:147
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION
@ SatParameters_BinaryMinizationAlgorithm_NO_BINARY_MINIMIZATION
Definition: sat_parameters.pb.h:146
operations_research::sat::SatParameters_FPRoundingMethod_FPRoundingMethod_MIN
constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MIN
Definition: sat_parameters.pb.h:327
operations_research::sat::SatParameters_ClauseOrdering_Name
const std::string & SatParameters_ClauseOrdering_Name(T enum_t_value)
Definition: sat_parameters.pb.h:206
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MAX
Definition: sat_parameters.pb.h:275
operations_research::sat::SatParameters_MaxSatAssumptionOrder
SatParameters_MaxSatAssumptionOrder
Definition: sat_parameters.pb.h:244
operations_research::sat::SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT
@ SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_WEIGHT
Definition: sat_parameters.pb.h:247
operations_research::sat::SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER
@ SatParameters_MaxSatAssumptionOrder_DEFAULT_ASSUMPTION_ORDER
Definition: sat_parameters.pb.h:245
operations_research::sat::SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH
@ SatParameters_MaxSatAssumptionOrder_ORDER_ASSUMPTION_BY_DEPTH
Definition: sat_parameters.pb.h:246
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_ConflictMinimizationAlgorithm_descriptor()
operations_research::sat::SatParameters_FPRoundingMethod_FPRoundingMethod_MAX
constexpr SatParameters_FPRoundingMethod SatParameters_FPRoundingMethod_FPRoundingMethod_MAX
Definition: sat_parameters.pb.h:328
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_BinaryMinizationAlgorithm_descriptor()
operations_research::sat::SatParameters_SearchBranching_IsValid
bool SatParameters_SearchBranching_IsValid(int value)
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_IsValid
bool SatParameters_ConflictMinimizationAlgorithm_IsValid(int value)
operations_research::sat::SatParameters_RestartAlgorithm
SatParameters_RestartAlgorithm
Definition: sat_parameters.pb.h:218
operations_research::sat::SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART
@ SatParameters_RestartAlgorithm_DL_MOVING_AVERAGE_RESTART
Definition: sat_parameters.pb.h:221
operations_research::sat::SatParameters_RestartAlgorithm_FIXED_RESTART
@ SatParameters_RestartAlgorithm_FIXED_RESTART
Definition: sat_parameters.pb.h:223
operations_research::sat::SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART
@ SatParameters_RestartAlgorithm_LBD_MOVING_AVERAGE_RESTART
Definition: sat_parameters.pb.h:222
operations_research::sat::SatParameters_RestartAlgorithm_LUBY_RESTART
@ SatParameters_RestartAlgorithm_LUBY_RESTART
Definition: sat_parameters.pb.h:220
operations_research::sat::SatParameters_RestartAlgorithm_NO_RESTART
@ SatParameters_RestartAlgorithm_NO_RESTART
Definition: sat_parameters.pb.h:219
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE
constexpr int SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_ARRAYSIZE
Definition: sat_parameters.pb.h:129
operations_research::sat::SatParameters_RestartAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_RestartAlgorithm_descriptor()
operations_research::sat::SatParameters_VariableOrder_Name
const std::string & SatParameters_VariableOrder_Name(T enum_t_value)
Definition: sat_parameters.pb.h:82
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_MaxSatStratificationAlgorithm_descriptor()
operations_research::sat::SatParameters_Polarity
SatParameters_Polarity
Definition: sat_parameters.pb.h:94
operations_research::sat::SatParameters_Polarity_POLARITY_FALSE
@ SatParameters_Polarity_POLARITY_FALSE
Definition: sat_parameters.pb.h:96
operations_research::sat::SatParameters_Polarity_POLARITY_WEIGHTED_SIGN
@ SatParameters_Polarity_POLARITY_WEIGHTED_SIGN
Definition: sat_parameters.pb.h:98
operations_research::sat::SatParameters_Polarity_POLARITY_TRUE
@ SatParameters_Polarity_POLARITY_TRUE
Definition: sat_parameters.pb.h:95
operations_research::sat::SatParameters_Polarity_POLARITY_RANDOM
@ SatParameters_Polarity_POLARITY_RANDOM
Definition: sat_parameters.pb.h:97
operations_research::sat::SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN
@ SatParameters_Polarity_POLARITY_REVERSE_WEIGHTED_SIGN
Definition: sat_parameters.pb.h:99
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_MIN
Definition: sat_parameters.pb.h:274
operations_research::sat::SatParameters_MaxSatAssumptionOrder_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_MaxSatAssumptionOrder_descriptor()
operations_research::sat::SatParameters_MaxSatAssumptionOrder_Name
const std::string & SatParameters_MaxSatAssumptionOrder_Name(T enum_t_value)
Definition: sat_parameters.pb.h:256
operations_research::sat::SatParameters_ClauseOrdering_IsValid
bool SatParameters_ClauseOrdering_IsValid(int value)
operations_research::sat::SatParameters_SearchBranching_SearchBranching_MAX
constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MAX
Definition: sat_parameters.pb.h:303
operations_research::sat::SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE
constexpr int SatParameters_FPRoundingMethod_FPRoundingMethod_ARRAYSIZE
Definition: sat_parameters.pb.h:329
operations_research::sat::SatParameters_MaxSatAssumptionOrder_Parse
bool SatParameters_MaxSatAssumptionOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_MaxSatAssumptionOrder *value)
Definition: sat_parameters.pb.h:263
operations_research::sat::SatParameters_ClauseOrdering_ClauseOrdering_MAX
constexpr SatParameters_ClauseOrdering SatParameters_ClauseOrdering_ClauseOrdering_MAX
Definition: sat_parameters.pb.h:201
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters_ConflictMinimizationAlgorithm_ConflictMinimizationAlgorithm_MAX
Definition: sat_parameters.pb.h:128
operations_research::sat::SatParameters_RestartAlgorithm_RestartAlgorithm_MAX
constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MAX
Definition: sat_parameters.pb.h:227
operations_research::sat::SatParameters_RestartAlgorithm_IsValid
bool SatParameters_RestartAlgorithm_IsValid(int value)
operations_research::sat::SatParameters_VariableOrder_VariableOrder_ARRAYSIZE
constexpr int SatParameters_VariableOrder_VariableOrder_ARRAYSIZE
Definition: sat_parameters.pb.h:78
operations_research::sat::SatParameters_SearchBranching_Name
const std::string & SatParameters_SearchBranching_Name(T enum_t_value)
Definition: sat_parameters.pb.h:308
operations_research::sat::SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN
constexpr SatParameters_MaxSatAssumptionOrder SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_MIN
Definition: sat_parameters.pb.h:250
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE
constexpr int SatParameters_MaxSatStratificationAlgorithm_MaxSatStratificationAlgorithm_ARRAYSIZE
Definition: sat_parameters.pb.h:276
operations_research::sat::SatParameters_RestartAlgorithm_RestartAlgorithm_MIN
constexpr SatParameters_RestartAlgorithm SatParameters_RestartAlgorithm_RestartAlgorithm_MIN
Definition: sat_parameters.pb.h:226
operations_research::sat::SatParameters_ClauseProtection_IsValid
bool SatParameters_ClauseProtection_IsValid(int value)
operations_research::sat::SatParameters_ClauseProtection_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_ClauseProtection_descriptor()
operations_research::sat::SatParameters_FPRoundingMethod_descriptor
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor * SatParameters_FPRoundingMethod_descriptor()
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_Parse
bool SatParameters_ConflictMinimizationAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_ConflictMinimizationAlgorithm *value)
Definition: sat_parameters.pb.h:140
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm
SatParameters_MaxSatStratificationAlgorithm
Definition: sat_parameters.pb.h:268
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE
@ SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_NONE
Definition: sat_parameters.pb.h:269
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT
@ SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_DESCENT
Definition: sat_parameters.pb.h:270
operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT
@ SatParameters_MaxSatStratificationAlgorithm_STRATIFICATION_ASCENT
Definition: sat_parameters.pb.h:271
operations_research::sat::SatParameters_VariableOrder_Parse
bool SatParameters_VariableOrder_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_VariableOrder *value)
Definition: sat_parameters.pb.h:89
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE
constexpr int SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_ARRAYSIZE
Definition: sat_parameters.pb.h:155
operations_research::sat::SatParameters_ClauseProtection_Name
const std::string & SatParameters_ClauseProtection_Name(T enum_t_value)
Definition: sat_parameters.pb.h:183
operations_research::sat::SatParameters_SearchBranching_Parse
bool SatParameters_SearchBranching_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_SearchBranching *value)
Definition: sat_parameters.pb.h:315
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters_BinaryMinizationAlgorithm_BinaryMinizationAlgorithm_MIN
Definition: sat_parameters.pb.h:153
operations_research::sat::SatParameters_SearchBranching_SearchBranching_MIN
constexpr SatParameters_SearchBranching SatParameters_SearchBranching_SearchBranching_MIN
Definition: sat_parameters.pb.h:302
operations_research::sat::SatParameters_BinaryMinizationAlgorithm_Name
const std::string & SatParameters_BinaryMinizationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:159
operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_Name
const std::string & SatParameters_ConflictMinimizationAlgorithm_Name(T enum_t_value)
Definition: sat_parameters.pb.h:133
operations_research::sat::SatParameters_Polarity_Polarity_ARRAYSIZE
constexpr int SatParameters_Polarity_Polarity_ARRAYSIZE
Definition: sat_parameters.pb.h:104
operations_research::sat::SatParameters_Polarity_Name
const std::string & SatParameters_Polarity_Name(T enum_t_value)
Definition: sat_parameters.pb.h:108
operations_research::sat::SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE
constexpr int SatParameters_MaxSatAssumptionOrder_MaxSatAssumptionOrder_ARRAYSIZE
Definition: sat_parameters.pb.h:252
operations_research::sat::SatParameters_ClauseProtection
SatParameters_ClauseProtection
Definition: sat_parameters.pb.h:171
operations_research::sat::SatParameters_ClauseProtection_PROTECTION_NONE
@ SatParameters_ClauseProtection_PROTECTION_NONE
Definition: sat_parameters.pb.h:172
operations_research::sat::SatParameters_ClauseProtection_PROTECTION_ALWAYS
@ SatParameters_ClauseProtection_PROTECTION_ALWAYS
Definition: sat_parameters.pb.h:173
operations_research::sat::SatParameters_ClauseProtection_PROTECTION_LBD
@ SatParameters_ClauseProtection_PROTECTION_LBD
Definition: sat_parameters.pb.h:174
operations_research::sat::SatParameters_FPRoundingMethod_Parse
bool SatParameters_FPRoundingMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SatParameters_FPRoundingMethod *value)
Definition: sat_parameters.pb.h:340
operations_research
Definition: cp_model.h:52
descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto
Definition: sat_parameters.pb.h:45
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::offsets
static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]
Definition: sat_parameters.pb.h:54
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::PROTOBUF_SECTION_VARIABLE
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::PROTOBUF_SECTION_VARIABLE
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::PROTOBUF_SECTION_VARIABLE
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1] PROTOBUF_SECTION_VARIABLE(protodesc_cold)
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::serialization_table
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]
Definition: sat_parameters.pb.h:53
TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::field_metadata
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]
Definition: sat_parameters.pb.h:52