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