10#include "google/protobuf/io/coded_stream.h"
11#include "google/protobuf/generated_message_tctable_impl.h"
12#include "google/protobuf/extension_set.h"
13#include "google/protobuf/generated_message_util.h"
14#include "google/protobuf/wire_format_lite.h"
15#include "google/protobuf/descriptor.h"
16#include "google/protobuf/generated_message_reflection.h"
17#include "google/protobuf/reflection_ops.h"
18#include "google/protobuf/wire_format.h"
22#include "google/protobuf/port_def.inc"
23PROTOBUF_PRAGMA_INIT_SEG
26namespace _fl = ::google::protobuf::internal::field_layout;
30inline constexpr SatParameters::Impl_::Impl_(
31 ::_pbi::ConstantInitialized) noexcept
34 clause_cleanup_target_{0},
35 random_polarity_ratio_{0},
36 log_search_progress_{
false},
37 use_pb_resolution_{
false},
38 use_optimization_hints_{
true},
39 use_phase_saving_{
true},
40 use_precedences_in_disjunctive_constraint_{
true},
43 variable_activity_decay_{0.8},
44 max_variable_activity_value_{1e+100},
45 clause_activity_decay_{0.999},
46 clause_cleanup_period_{10000},
47 glucose_decay_increment_period_{5000},
48 max_clause_activity_value_{1e+20},
49 glucose_max_decay_{0.95},
50 glucose_decay_increment_{0.01},
53 max_time_in_seconds_{std::numeric_limits<double>::infinity()},
54 max_number_of_conflicts_{::int64_t{9223372036854775807}},
55 restart_algorithms_{},
61 default_restart_algorithms_(
62 &::google::protobuf::internal::fixed_address_empty_string,
63 ::_pbi::ConstantInitialized()),
65 &::google::protobuf::internal::fixed_address_empty_string,
66 ::_pbi::ConstantInitialized()),
68 &::google::protobuf::internal::fixed_address_empty_string,
69 ::_pbi::ConstantInitialized()),
70 random_branches_ratio_{0},
72 minimize_reduction_during_pb_resolution_{
false},
73 max_sat_reverse_assumption_order_{
false},
74 use_blocking_restart_{
false},
75 use_erwa_heuristic_{
false},
77 num_conflicts_before_strategy_changes_{0},
78 strategy_change_increase_ratio_{0},
79 initial_variables_activity_{0},
80 also_bump_variables_in_conflict_reasons_{
false},
81 use_overload_checker_in_cumulative_{
false},
82 use_timetable_edge_finding_in_cumulative_{
false},
83 optimize_with_core_{
false},
85 optimize_with_max_hs_{
false},
86 enumerate_all_solutions_{
false},
87 only_add_cuts_at_level_zero_{
false},
88 stop_after_first_solution_{
false},
89 num_search_workers_{0},
90 search_random_variable_pool_size_{::int64_t{0}},
92 randomize_search_{
false},
93 use_optional_variables_{
false},
94 exploit_best_solution_{
false},
95 interleave_batch_size_{0},
96 fill_tightened_domains_in_response_{
false},
97 use_combined_no_overlap_{
false},
98 interleave_search_{
false},
99 diversify_lns_params_{
false},
100 debug_max_num_presolve_operations_{0},
101 relative_gap_limit_{0},
102 stop_after_presolve_{
false},
103 exploit_relaxation_solution_{
false},
104 debug_postsolve_with_full_solver_{
false},
106 expand_alldiff_constraints_{
false},
107 keep_all_feasible_solutions_in_presolve_{
false},
108 presolve_extract_integer_enforcement_{
false},
109 polish_lp_solution_{
false},
110 use_probing_search_{
false},
111 permute_variable_randomly_{
false},
112 permute_presolve_constraint_order_{
false},
113 use_absl_random_{
false},
114 disable_constraint_expansion_{
false},
115 log_to_response_{
false},
116 optimize_with_lb_tree_search_{
false},
117 log_subsolver_statistics_{
false},
118 fix_variables_to_their_hinted_value_{
false},
119 fill_additional_solutions_in_response_{
false},
120 debug_crash_on_bad_hint_{
false},
121 add_objective_cut_{
false},
123 use_timetabling_in_no_overlap_2d_{
false},
124 use_energetic_reasoning_in_no_overlap_2d_{
false},
125 use_hard_precedences_in_cumulative_{
false},
126 detect_table_with_cost_{
false},
127 exploit_all_precedences_{
false},
128 only_solve_ip_{
false},
129 encode_complex_linear_constraint_with_integer_{
false},
130 mip_scale_large_domain_{
false},
131 use_objective_lb_search_{
false},
132 use_strong_propagation_in_disjunctive_{
false},
133 use_shared_tree_search_{
false},
136 num_violation_ls_{0},
137 stop_after_root_propagation_{
false},
138 use_objective_shaving_search_{
false},
139 push_all_tasks_toward_start_{
false},
140 use_dynamic_precedence_in_disjunctive_{
false},
141 use_dynamic_precedence_in_cumulative_{
false},
142 use_area_energetic_reasoning_in_no_overlap_2d_{
false},
143 detect_linearized_product_{
false},
144 mip_treat_high_magnitude_bounds_as_infinity_{
false},
145 max_lin_max_size_for_expansion_{0},
146 save_lp_basis_in_lb_tree_search_{
false},
147 use_conservative_scale_overload_checker_{
false},
148 encode_cumulative_as_reservoir_{
false},
149 expand_reservoir_using_circuit_{
false},
150 max_num_deterministic_batches_{0},
151 num_full_subsolvers_{0},
152 inprocessing_minimization_use_all_orderings_{
false},
153 use_try_edge_reasoning_in_no_overlap_2d_{
false},
154 use_symmetry_in_lp_{
false},
155 keep_symmetry_in_presolve_{
false},
156 routing_cut_subset_size_for_binary_relation_bound_{0},
157 debug_crash_if_presolve_breaks_hint_{
false},
158 polarity_exploit_ls_hints_{
false},
159 use_all_different_for_circuit_{
false},
160 filter_sat_postsolve_clauses_{
false},
161 routing_cut_subset_size_for_tight_binary_relation_bound_{0},
162 maximum_regions_to_split_in_disconnected_no_overlap_2d_{0},
163 share_linear2_bounds_{
false},
164 use_chronological_backtracking_{
false},
165 load_at_most_ones_in_sat_presolve_{
false},
166 use_new_integer_conflict_resolution_{
false},
167 clause_cleanup_period_increment_{0},
168 debug_crash_if_lrat_check_fails_{
false},
169 check_lrat_proof_{
false},
170 output_lrat_proof_{
false},
171 check_drat_proof_{
false},
172 clause_cleanup_lbd_tier1_{0},
173 clause_cleanup_lbd_tier2_{0},
174 output_drat_proof_{
false},
175 check_merged_lrat_proof_{
false},
176 inprocessing_use_sat_sweeping_{
false},
177 max_memory_in_mb_{::int64_t{10000}},
179 pb_cleanup_increment_{200},
180 pb_cleanup_ratio_{0.5},
181 core_minimization_level_{2},
183 presolve_bve_threshold_{500},
184 presolve_bve_clause_weight_{3},
185 presolve_probing_deterministic_time_limit_{30},
186 clause_cleanup_lbd_bound_{5},
187 restart_running_window_size_{50},
188 restart_dl_average_ratio_{1},
189 count_assumption_levels_in_lbd_{
true},
190 subsumption_during_conflict_analysis_{
true},
191 presolve_use_bva_{
true},
192 use_disjunctive_constraint_in_cumulative_{
true},
193 blocking_restart_window_size_{5000},
194 blocking_restart_multiplier_{1.4},
195 max_deterministic_time_{std::numeric_limits<double>::infinity()},
196 restart_lbd_average_ratio_{1},
197 presolve_bva_threshold_{1},
198 find_multiple_cores_{
true},
199 cp_model_presolve_{
true},
200 presolve_blocked_clause_{
true},
201 cover_optimization_{
true},
202 linearization_level_{1},
203 max_num_cuts_{10000},
204 cp_model_use_sat_presolve_{
true},
205 exploit_integer_lp_solution_{
true},
206 auto_detect_greater_than_at_least_one_of_{
true},
207 instantiate_all_variables_{
true},
208 binary_search_num_conflicts_{-1},
209 boolean_encoding_level_{1},
210 cp_model_probing_level_{2},
211 use_exact_lp_reason_{
true},
212 add_lp_constraints_lazily_{
true},
213 share_objective_bounds_{
true},
214 share_level_zero_bounds_{
true},
215 max_integer_rounding_scaling_{600},
216 min_orthogonality_for_lp_constraints_{0.05},
217 exploit_all_lp_solution_{
true},
221 max_consecutive_inactive_count_{100},
222 pseudo_cost_reliability_threshold_{::int64_t{100}},
223 mip_max_bound_{10000000},
224 new_constraints_batch_size_{50},
225 mip_max_activity_exponent_{53},
227 mip_wanted_precision_{1e-06},
228 mip_check_precision_{0.0001},
229 max_presolve_iterations_{3},
230 exploit_objective_{
true},
231 catch_sigint_signal_{
true},
232 use_implied_bounds_{
true},
233 add_lin_max_cuts_{
true},
234 merge_no_overlap_work_limit_{1000000000000},
235 merge_at_most_one_work_limit_{100000000},
236 presolve_substitution_level_{1},
237 max_all_diff_cut_size_{64},
238 hint_conflict_limit_{10},
239 max_cut_rounds_at_level_zero_{1},
240 cut_max_active_count_value_{10000000000},
241 cut_active_count_decay_{0.8},
242 absolute_gap_limit_{0.0001},
243 cut_cleanup_target_{1000},
245 use_sat_inprocessing_{
true},
246 use_feasibility_pump_{
true},
247 mip_automatically_scale_variables_{
true},
248 add_zero_half_cuts_{
true},
249 polarity_rephase_increment_{1000},
250 add_clique_cuts_{
true},
251 convert_intervals_{
true},
252 expand_reservoir_constraints_{
true},
253 log_to_stdout_{
true},
255 clause_cleanup_ratio_{0.5},
256 max_domain_size_when_encoding_eq_neq_constraints_{16},
257 solution_pool_size_{3},
258 mip_max_valid_magnitude_{1e+20},
259 presolve_inclusion_work_limit_{::int64_t{100000000}},
261 mip_compute_true_objective_bound_{
true},
263 share_binary_clauses_{
true},
264 use_dual_scheduling_heuristics_{
true},
265 shaving_deterministic_time_in_probing_search_{0.001},
266 shaving_search_deterministic_time_{0.1},
267 propagation_loop_detection_factor_{10},
268 table_compression_level_{2},
269 root_lp_iterations_{2000},
270 probing_deterministic_time_limit_{1},
271 mip_drop_tolerance_{1e-16},
272 max_size_to_create_precedence_literals_in_disjunctive_{60},
273 shared_tree_num_workers_{-1},
274 new_linear_propagation_{
true},
275 infer_all_diffs_{
true},
276 find_big_linear_overlap_{
true},
277 feasibility_jump_enable_restarts_{
true},
278 shared_tree_max_nodes_per_worker_{10000},
279 feasibility_jump_decay_{0.95},
280 feasibility_jump_var_randomization_probability_{0.05},
281 feasibility_jump_var_perburbation_range_ratio_{0.2},
282 violation_ls_perturbation_period_{100},
283 linear_split_size_{100},
284 feasibility_jump_linearization_level_{2},
285 feasibility_jump_restart_factor_{1},
286 violation_ls_compound_move_probability_{0.5},
287 max_num_intervals_for_timetable_edge_finding_{100},
288 mip_presolve_level_{2},
289 lp_primal_tolerance_{1e-07},
290 feasibility_jump_max_expanded_constraint_size_{500},
291 use_lb_relax_lns_{
true},
292 use_feasibility_jump_{
true},
293 use_extended_probing_{
true},
295 lp_dual_tolerance_{1e-07},
296 at_most_one_max_expansion_size_{3},
297 probing_num_combinations_limit_{20000},
298 inprocessing_dtime_ratio_{0.2},
299 inprocessing_probing_dtime_{1},
300 inprocessing_minimization_dtime_{1},
301 max_pairs_pairwise_reasoning_in_no_overlap_2d_{1250},
302 shared_tree_worker_min_restarts_per_subtree_{1},
303 shared_tree_open_leaves_per_worker_{2},
304 variables_shaving_level_{-1},
306 share_glue_clauses_{
true},
307 shared_tree_worker_enable_trail_sharing_{
true},
308 inprocessing_minimization_use_conflict_analysis_{
true},
309 shaving_search_threshold_{::int64_t{64}},
310 feasibility_jump_batch_dtime_{0.1},
311 lb_relax_num_workers_threshold_{16},
312 shared_tree_balance_tolerance_{1},
313 symmetry_detection_deterministic_time_limit_{1},
314 lns_initial_difficulty_{0.5},
315 lns_initial_deterministic_limit_{0.1},
316 minimize_shared_clauses_{
true},
317 shared_tree_worker_enable_phase_sharing_{
true},
318 remove_fixed_variables_early_{
true},
319 use_linear3_for_no_overlap_2d_precedences_{
true},
320 routing_cut_subset_size_for_exact_binary_relation_bound_{8},
321 routing_cut_dp_effort_{10000000},
322 routing_cut_max_infeasible_path_length_{6},
323 routing_cut_subset_size_for_shortest_paths_bound_{8},
324 max_alldiff_domain_size_{256},
325 no_overlap_2d_boolean_relations_limit_{10},
326 share_glue_clauses_dtime_{1},
327 alternative_pool_size_{1},
328 transitive_precedences_work_limit_{1000000},
329 shared_tree_split_min_dtime_{0.1},
330 solution_pool_diversity_limit_{10},
331 max_backjump_levels_{50},
332 chronological_backtrack_min_conflicts_{1000},
333 max_domain_size_for_linear2_expansion_{8},
334 find_clauses_that_are_exactly_one_{
true},
335 create_1uip_boolean_during_icr_{
true},
336 inprocessing_use_congruence_closure_{
true},
337 extra_subsumption_during_conflict_analysis_{
true},
338 eagerly_subsume_last_n_conflicts_{4},
339 max_drat_time_in_seconds_{std::numeric_limits<double>::infinity()},
340 decision_subsumption_during_conflict_analysis_{
true},
341 subsume_during_vivification_{
true} {}
345#if defined(PROTOBUF_CUSTOM_VTABLE)
348 : ::google::protobuf::Message(),
350 _impl_(::_pbi::ConstantInitialized()) {
360PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL
364static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL
366static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
982static const ::_pbi::MigrationSchema
991 "\n ortools/sat/sat_parameters.proto\022\027oper"
992 "ations_research.sat\"\264u\n\rSatParameters\022\017\n"
993 "\004name\030\253\001 \001(\t:\000\022`\n\030preferred_variable_ord"
994 "er\030\001 \001(\01624.operations_research.sat.SatPa"
995 "rameters.VariableOrder:\010IN_ORDER\022Y\n\020init"
996 "ial_polarity\030\002 \001(\0162/.operations_research"
997 ".sat.SatParameters.Polarity:\016POLARITY_FA"
998 "LSE\022\036\n\020use_phase_saving\030, \001(\010:\004true\022)\n\032p"
999 "olarity_rephase_increment\030\250\001 \001(\005:\0041000\022)"
1000 "\n\031polarity_exploit_ls_hints\030\265\002 \001(\010:\005fals"
1001 "e\022 \n\025random_polarity_ratio\030- \001(\001:\0010\022 \n\025r"
1002 "andom_branches_ratio\030 \001(\001:\0010\022!\n\022use_erw"
1003 "a_heuristic\030K \001(\010:\005false\022%\n\032initial_vari"
1004 "ables_activity\030L \001(\001:\0010\0226\n\'also_bump_var"
1005 "iables_in_conflict_reasons\030M \001(\010:\005false\022"
1006 "o\n\026minimization_algorithm\030\004 \001(\0162D.operat"
1007 "ions_research.sat.SatParameters.Conflict"
1008 "MinimizationAlgorithm:\tRECURSIVE\022\223\001\n\035bin"
1009 "ary_minimization_algorithm\030\" \001(\0162@.opera"
1010 "tions_research.sat.SatParameters.BinaryM"
1011 "inizationAlgorithm:*BINARY_MINIMIZATION_"
1012 "FROM_UIP_AND_DECISIONS\0222\n$subsumption_du"
1013 "ring_conflict_analysis\0308 \001(\010:\004true\0229\n*ex"
1014 "tra_subsumption_during_conflict_analysis"
1015 "\030\337\002 \001(\010:\004true\022<\n-decision_subsumption_du"
1016 "ring_conflict_analysis\030\341\002 \001(\010:\004true\022,\n e"
1017 "agerly_subsume_last_n_conflicts\030\327\002 \001(\005:\001"
1018 "4\022*\n\033subsume_during_vivification\030\343\002 \001(\010:"
1019 "\004true\022.\n\036use_chronological_backtracking\030"
1020 "\312\002 \001(\010:\005false\022 \n\023max_backjump_levels\030\313\002 "
1021 "\001(\005:\00250\0224\n%chronological_backtrack_min_c"
1022 "onflicts\030\314\002 \001(\005:\0041000\022$\n\025clause_cleanup_"
1023 "period\030\013 \001(\005:\00510000\022+\n\037clause_cleanup_pe"
1024 "riod_increment\030\321\002 \001(\005:\0010\022 \n\025clause_clean"
1025 "up_target\030\r \001(\005:\0010\022\"\n\024clause_cleanup_rat"
1026 "io\030\276\001 \001(\001:\0030.5\022#\n\030clause_cleanup_lbd_bou"
1027 "nd\030; \001(\005:\0015\022$\n\030clause_cleanup_lbd_tier1\030"
1028 "\335\002 \001(\005:\0010\022$\n\030clause_cleanup_lbd_tier2\030\336\002"
1029 " \001(\005:\0010\022g\n\027clause_cleanup_ordering\030< \001(\016"
1030 "25.operations_research.sat.SatParameters"
1031 ".ClauseOrdering:\017CLAUSE_ACTIVITY\022!\n\024pb_c"
1032 "leanup_increment\030. \001(\005:\003200\022\035\n\020pb_cleanu"
1033 "p_ratio\030/ \001(\001:\0030.5\022$\n\027variable_activity_"
1034 "decay\030\017 \001(\001:\0030.8\022+\n\033max_variable_activit"
1035 "y_value\030\020 \001(\001:\0061e+100\022\037\n\021glucose_max_dec"
1036 "ay\030\026 \001(\001:\0040.95\022%\n\027glucose_decay_incremen"
1037 "t\030\027 \001(\001:\0040.01\022,\n\036glucose_decay_increment"
1038 "_period\030\030 \001(\005:\0045000\022$\n\025clause_activity_d"
1039 "ecay\030\021 \001(\001:\0050.999\022(\n\031max_clause_activity"
1040 "_value\030\022 \001(\001:\0051e+20\022S\n\022restart_algorithm"
1041 "s\030= \003(\01627.operations_research.sat.SatPar"
1042 "ameters.RestartAlgorithm\022e\n\032default_rest"
1043 "art_algorithms\030F \001(\t:ALUBY_RESTART,LBD_M"
1044 "OVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_"
1045 "RESTART\022\032\n\016restart_period\030\036 \001(\005:\00250\022\'\n\033r"
1046 "estart_running_window_size\030> \001(\005:\00250\022#\n\030"
1047 "restart_dl_average_ratio\030\? \001(\001:\0011\022$\n\031res"
1048 "tart_lbd_average_ratio\030G \001(\001:\0011\022#\n\024use_b"
1049 "locking_restart\030@ \001(\010:\005false\022*\n\034blocking"
1050 "_restart_window_size\030A \001(\005:\0045000\022(\n\033bloc"
1051 "king_restart_multiplier\030B \001(\001:\0031.4\0220\n%nu"
1052 "m_conflicts_before_strategy_changes\030D \001("
1053 "\005:\0010\022)\n\036strategy_change_increase_ratio\030E"
1054 " \001(\001:\0010\022 \n\023max_time_in_seconds\030$ \001(\001:\003in"
1055 "f\022#\n\026max_deterministic_time\030C \001(\001:\003inf\022)"
1056 "\n\035max_num_deterministic_batches\030\243\002 \001(\005:\001"
1057 "0\0224\n\027max_number_of_conflicts\030% \001(\003:\0239223"
1058 "372036854775807\022\037\n\020max_memory_in_mb\030( \001("
1059 "\003:\00510000\022#\n\022absolute_gap_limit\030\237\001 \001(\001:\0060"
1060 ".0001\022\036\n\022relative_gap_limit\030\240\001 \001(\001:\0010\022\026\n"
1061 "\013random_seed\030\037 \001(\005:\0011\022)\n\031permute_variabl"
1062 "e_randomly\030\262\001 \001(\010:\005false\0221\n!permute_pres"
1063 "olve_constraint_order\030\263\001 \001(\010:\005false\022\037\n\017u"
1064 "se_absl_random\030\264\001 \001(\010:\005false\022\"\n\023log_sear"
1065 "ch_progress\030) \001(\010:\005false\022(\n\030log_subsolve"
1066 "r_statistics\030\275\001 \001(\010:\005false\022\025\n\nlog_prefix"
1067 "\030\271\001 \001(\t:\000\022\034\n\rlog_to_stdout\030\272\001 \001(\010:\004true\022"
1068 "\037\n\017log_to_response\030\273\001 \001(\010:\005false\022 \n\021use_"
1069 "pb_resolution\030+ \001(\010:\005false\0226\n\'minimize_r"
1070 "eduction_during_pb_resolution\0300 \001(\010:\005fal"
1071 "se\022,\n\036count_assumption_levels_in_lbd\0301 \001"
1072 "(\010:\004true\022#\n\026presolve_bve_threshold\0306 \001(\005"
1073 ":\003500\022,\n\034filter_sat_postsolve_clauses\030\304\002"
1074 " \001(\010:\005false\022%\n\032presolve_bve_clause_weigh"
1075 "t\0307 \001(\005:\0013\022,\n probing_deterministic_time"
1076 "_limit\030\342\001 \001(\001:\0011\0225\n)presolve_probing_det"
1077 "erministic_time_limit\0309 \001(\001:\00230\022%\n\027preso"
1078 "lve_blocked_clause\030X \001(\010:\004true\022\036\n\020presol"
1079 "ve_use_bva\030H \001(\010:\004true\022!\n\026presolve_bva_t"
1080 "hreshold\030I \001(\005:\0011\022#\n\027max_presolve_iterat"
1081 "ions\030\212\001 \001(\005:\0013\022\037\n\021cp_model_presolve\030V \001("
1082 "\010:\004true\022!\n\026cp_model_probing_level\030n \001(\005:"
1083 "\0012\022\'\n\031cp_model_use_sat_presolve\030] \001(\010:\004t"
1084 "rue\0221\n!load_at_most_ones_in_sat_presolve"
1085 "\030\317\002 \001(\010:\005false\022+\n\034remove_fixed_variables"
1086 "_early\030\266\002 \001(\010:\004true\022&\n\026detect_table_with"
1087 "_cost\030\330\001 \001(\010:\005false\022#\n\027table_compression"
1088 "_level\030\331\001 \001(\005:\0012\022*\n\032expand_alldiff_const"
1089 "raints\030\252\001 \001(\010:\005false\022%\n\027max_alldiff_doma"
1090 "in_size\030\300\002 \001(\005:\003256\022+\n\034expand_reservoir_"
1091 "constraints\030\266\001 \001(\010:\004true\0221\n%max_domain_s"
1092 "ize_for_linear2_expansion\030\324\002 \001(\005:\0018\022.\n\036e"
1093 "xpand_reservoir_using_circuit\030\240\002 \001(\010:\005fa"
1094 "lse\022.\n\036encode_cumulative_as_reservoir\030\237\002"
1095 " \001(\010:\005false\022*\n\036max_lin_max_size_for_expa"
1096 "nsion\030\230\002 \001(\005:\0010\022,\n\034disable_constraint_ex"
1097 "pansion\030\265\001 \001(\010:\005false\022=\n-encode_complex_"
1098 "linear_constraint_with_integer\030\337\001 \001(\010:\005f"
1099 "alse\0223\n\033merge_no_overlap_work_limit\030\221\001 \001"
1100 "(\001:\r1000000000000\0220\n\034merge_at_most_one_w"
1101 "ork_limit\030\222\001 \001(\001:\t100000000\022\'\n\033presolve_"
1102 "substitution_level\030\223\001 \001(\005:\0011\0224\n$presolve"
1103 "_extract_integer_enforcement\030\256\001 \001(\010:\005fal"
1104 "se\0221\n\035presolve_inclusion_work_limit\030\311\001 \001"
1105 "(\003:\t100000000\022\033\n\014ignore_names\030\312\001 \001(\010:\004tr"
1106 "ue\022\036\n\017infer_all_diffs\030\351\001 \001(\010:\004true\022&\n\027fi"
1107 "nd_big_linear_overlap\030\352\001 \001(\010:\004true\0220\n!fi"
1108 "nd_clauses_that_are_exactly_one\030\315\002 \001(\010:\004"
1109 "true\022#\n\024use_sat_inprocessing\030\243\001 \001(\010:\004tru"
1110 "e\022&\n\030inprocessing_dtime_ratio\030\221\002 \001(\001:\0030."
1111 "2\022&\n\032inprocessing_probing_dtime\030\222\002 \001(\001:\001"
1112 "1\022+\n\037inprocessing_minimization_dtime\030\223\002 "
1113 "\001(\001:\0011\022>\n/inprocessing_minimization_use_"
1114 "conflict_analysis\030\251\002 \001(\010:\004true\022;\n+inproc"
1115 "essing_minimization_use_all_orderings\030\252\002"
1116 " \001(\010:\005false\0222\n#inprocessing_use_congruen"
1117 "ce_closure\030\326\002 \001(\010:\004true\022-\n\035inprocessing_"
1118 "use_sat_sweeping\030\342\002 \001(\010:\005false\022\027\n\013num_wo"
1119 "rkers\030\316\001 \001(\005:\0010\022\035\n\022num_search_workers\030d "
1120 "\001(\005:\0010\022\037\n\023num_full_subsolvers\030\246\002 \001(\005:\0010\022"
1121 "\023\n\nsubsolvers\030\317\001 \003(\t\022\031\n\020extra_subsolvers"
1122 "\030\333\001 \003(\t\022\032\n\021ignore_subsolvers\030\321\001 \003(\t\022\032\n\021f"
1123 "ilter_subsolvers\030\245\002 \003(\t\022A\n\020subsolver_par"
1124 "ams\030\322\001 \003(\0132&.operations_research.sat.Sat"
1125 "Parameters\022!\n\021interleave_search\030\210\001 \001(\010:\005"
1126 "false\022!\n\025interleave_batch_size\030\206\001 \001(\005:\0010"
1127 "\022$\n\026share_objective_bounds\030q \001(\010:\004true\022%"
1128 "\n\027share_level_zero_bounds\030r \001(\010:\004true\022$\n"
1129 "\024share_linear2_bounds\030\306\002 \001(\010:\005false\022#\n\024s"
1130 "hare_binary_clauses\030\313\001 \001(\010:\004true\022!\n\022shar"
1131 "e_glue_clauses\030\235\002 \001(\010:\004true\022&\n\027minimize_"
1132 "shared_clauses\030\254\002 \001(\010:\004true\022$\n\030share_glu"
1133 "e_clauses_dtime\030\302\002 \001(\001:\0011\022 \n\020check_lrat_"
1134 "proof\030\330\002 \001(\010:\005false\022\'\n\027check_merged_lrat"
1135 "_proof\030\340\002 \001(\010:\005false\022!\n\021output_lrat_proo"
1136 "f\030\331\002 \001(\010:\005false\022 \n\020check_drat_proof\030\332\002 \001"
1137 "(\010:\005false\022!\n\021output_drat_proof\030\333\002 \001(\010:\005f"
1138 "alse\022&\n\030max_drat_time_in_seconds\030\334\002 \001(\001:"
1139 "\003inf\0220\n debug_postsolve_with_full_solver"
1140 "\030\242\001 \001(\010:\005false\022-\n!debug_max_num_presolve"
1141 "_operations\030\227\001 \001(\005:\0010\022\'\n\027debug_crash_on_"
1142 "bad_hint\030\303\001 \001(\010:\005false\0223\n#debug_crash_if"
1143 "_presolve_breaks_hint\030\262\002 \001(\010:\005false\022/\n\037d"
1144 "ebug_crash_if_lrat_check_fails\030\323\002 \001(\010:\005f"
1145 "alse\022$\n\026use_optimization_hints\030# \001(\010:\004tr"
1146 "ue\022\"\n\027core_minimization_level\0302 \001(\005:\0012\022!"
1147 "\n\023find_multiple_cores\030T \001(\010:\004true\022 \n\022cov"
1148 "er_optimization\030Y \001(\010:\004true\022x\n\030max_sat_a"
1149 "ssumption_order\0303 \001(\0162<.operations_resea"
1150 "rch.sat.SatParameters.MaxSatAssumptionOr"
1151 "der:\030DEFAULT_ASSUMPTION_ORDER\022/\n max_sat"
1152 "_reverse_assumption_order\0304 \001(\010:\005false\022|"
1153 "\n\026max_sat_stratification\0305 \001(\0162D.operati"
1154 "ons_research.sat.SatParameters.MaxSatStr"
1155 "atificationAlgorithm:\026STRATIFICATION_DES"
1156 "CENT\022.\n!propagation_loop_detection_facto"
1157 "r\030\335\001 \001(\001:\00210\0227\n)use_precedences_in_disju"
1158 "nctive_constraint\030J \001(\010:\004true\0223\n!transit"
1159 "ive_precedences_work_limit\030\307\002 \001(\005:\00710000"
1160 "00\022B\n5max_size_to_create_precedence_lite"
1161 "rals_in_disjunctive\030\345\001 \001(\005:\00260\0225\n%use_st"
1162 "rong_propagation_in_disjunctive\030\346\001 \001(\010:\005"
1163 "false\0225\n%use_dynamic_precedence_in_disju"
1164 "nctive\030\207\002 \001(\010:\005false\0224\n$use_dynamic_prec"
1165 "edence_in_cumulative\030\214\002 \001(\010:\005false\0221\n\"us"
1166 "e_overload_checker_in_cumulative\030N \001(\010:\005"
1167 "false\0227\n\'use_conservative_scale_overload"
1168 "_checker\030\236\002 \001(\010:\005false\0227\n(use_timetable_"
1169 "edge_finding_in_cumulative\030O \001(\010:\005false\022"
1170 ":\n,max_num_intervals_for_timetable_edge_"
1171 "finding\030\204\002 \001(\005:\003100\0222\n\"use_hard_preceden"
1172 "ces_in_cumulative\030\327\001 \001(\010:\005false\022\'\n\027explo"
1173 "it_all_precedences\030\334\001 \001(\010:\005false\0226\n(use_"
1174 "disjunctive_constraint_in_cumulative\030P \001"
1175 "(\010:\004true\0222\n%no_overlap_2d_boolean_relati"
1176 "ons_limit\030\301\002 \001(\005:\00210\0220\n use_timetabling_"
1177 "in_no_overlap_2d\030\310\001 \001(\010:\005false\0228\n(use_en"
1178 "ergetic_reasoning_in_no_overlap_2d\030\325\001 \001("
1179 "\010:\005false\022=\n-use_area_energetic_reasoning"
1180 "_in_no_overlap_2d\030\217\002 \001(\010:\005false\0227\n\'use_t"
1181 "ry_edge_reasoning_in_no_overlap_2d\030\253\002 \001("
1182 "\010:\005false\022<\n-max_pairs_pairwise_reasoning"
1183 "_in_no_overlap_2d\030\224\002 \001(\005:\0041250\022B\n6maximu"
1184 "m_regions_to_split_in_disconnected_no_ov"
1185 "erlap_2d\030\273\002 \001(\005:\0010\0228\n)use_linear3_for_no"
1186 "_overlap_2d_precedences\030\303\002 \001(\010:\004true\022-\n\036"
1187 "use_dual_scheduling_heuristics\030\326\001 \001(\010:\004t"
1188 "rue\022-\n\035use_all_different_for_circuit\030\267\002 "
1189 "\001(\010:\005false\022=\n1routing_cut_subset_size_fo"
1190 "r_binary_relation_bound\030\270\002 \001(\005:\0010\022C\n7rou"
1191 "ting_cut_subset_size_for_tight_binary_re"
1192 "lation_bound\030\271\002 \001(\005:\0010\022C\n7routing_cut_su"
1193 "bset_size_for_exact_binary_relation_boun"
1194 "d\030\274\002 \001(\005:\0018\022<\n0routing_cut_subset_size_f"
1195 "or_shortest_paths_bound\030\276\002 \001(\005:\0018\022(\n\025rou"
1196 "ting_cut_dp_effort\030\272\002 \001(\001:\01010000000\0222\n&r"
1197 "outing_cut_max_infeasible_path_length\030\275\002"
1198 " \001(\005:\0016\022b\n\020search_branching\030R \001(\01626.oper"
1199 "ations_research.sat.SatParameters.Search"
1200 "Branching:\020AUTOMATIC_SEARCH\022 \n\023hint_conf"
1201 "lict_limit\030\231\001 \001(\005:\00210\022\033\n\013repair_hint\030\247\001 "
1202 "\001(\010:\005false\0223\n#fix_variables_to_their_hin"
1203 "ted_value\030\300\001 \001(\010:\005false\022\"\n\022use_probing_s"
1204 "earch\030\260\001 \001(\010:\005false\022#\n\024use_extended_prob"
1205 "ing\030\215\002 \001(\010:\004true\022.\n\036probing_num_combinat"
1206 "ions_limit\030\220\002 \001(\005:\00520000\022<\n,shaving_dete"
1207 "rministic_time_in_probing_search\030\314\001 \001(\001:"
1208 "\0050.001\022/\n!shaving_search_deterministic_t"
1209 "ime\030\315\001 \001(\001:\0030.1\022%\n\030shaving_search_thresh"
1210 "old\030\242\002 \001(\003:\00264\022\'\n\027use_objective_lb_searc"
1211 "h\030\344\001 \001(\010:\005false\022,\n\034use_objective_shaving"
1212 "_search\030\375\001 \001(\010:\005false\022$\n\027variables_shavi"
1213 "ng_level\030\241\002 \001(\005:\002-1\022.\n!pseudo_cost_relia"
1214 "bility_threshold\030{ \001(\003:\003100\022!\n\022optimize_"
1215 "with_core\030S \001(\010:\005false\022,\n\034optimize_with_"
1216 "lb_tree_search\030\274\001 \001(\010:\005false\022/\n\037save_lp_"
1217 "basis_in_lb_tree_search\030\234\002 \001(\010:\005false\022\'\n"
1218 "\033binary_search_num_conflicts\030c \001(\005:\002-1\022#"
1219 "\n\024optimize_with_max_hs\030U \001(\010:\005false\022#\n\024u"
1220 "se_feasibility_jump\030\211\002 \001(\010:\004true\022\033\n\013use_"
1221 "ls_only\030\360\001 \001(\010:\005false\022%\n\026feasibility_jum"
1222 "p_decay\030\362\001 \001(\001:\0040.95\0220\n$feasibility_jump"
1223 "_linearization_level\030\201\002 \001(\005:\0012\022+\n\037feasib"
1224 "ility_jump_restart_factor\030\202\002 \001(\005:\0011\022*\n\034f"
1225 "easibility_jump_batch_dtime\030\244\002 \001(\001:\0030.1\022"
1226 "=\n.feasibility_jump_var_randomization_pr"
1227 "obability\030\367\001 \001(\001:\0040.05\022;\n-feasibility_ju"
1228 "mp_var_perburbation_range_ratio\030\370\001 \001(\001:\003"
1229 "0.2\022/\n feasibility_jump_enable_restarts\030"
1230 "\372\001 \001(\010:\004true\022;\n-feasibility_jump_max_exp"
1231 "anded_constraint_size\030\210\002 \001(\005:\003500\022\034\n\020num"
1232 "_violation_ls\030\364\001 \001(\005:\0010\022.\n violation_ls_"
1233 "perturbation_period\030\371\001 \001(\005:\003100\0224\n&viola"
1234 "tion_ls_compound_move_probability\030\203\002 \001(\001"
1235 ":\0030.5\022$\n\027shared_tree_num_workers\030\353\001 \001(\005:"
1236 "\002-1\022&\n\026use_shared_tree_search\030\354\001 \001(\010:\005fa"
1237 "lse\0227\n+shared_tree_worker_min_restarts_p"
1238 "er_subtree\030\232\002 \001(\005:\0011\0226\n\'shared_tree_work"
1239 "er_enable_trail_sharing\030\247\002 \001(\010:\004true\0226\n\'"
1240 "shared_tree_worker_enable_phase_sharing\030"
1241 "\260\002 \001(\010:\004true\022.\n\"shared_tree_open_leaves_"
1242 "per_worker\030\231\002 \001(\001:\0012\0220\n shared_tree_max_"
1243 "nodes_per_worker\030\356\001 \001(\005:\00510000\022x\n\032shared"
1244 "_tree_split_strategy\030\357\001 \001(\0162>.operations"
1245 "_research.sat.SatParameters.SharedTreeSp"
1246 "litStrategy:\023SPLIT_STRATEGY_AUTO\022)\n\035shar"
1247 "ed_tree_balance_tolerance\030\261\002 \001(\005:\0011\022)\n\033s"
1248 "hared_tree_split_min_dtime\030\310\002 \001(\001:\0030.1\022&"
1249 "\n\027enumerate_all_solutions\030W \001(\010:\005false\0227"
1250 "\n\'keep_all_feasible_solutions_in_presolv"
1251 "e\030\255\001 \001(\010:\005false\0222\n\"fill_tightened_domain"
1252 "s_in_response\030\204\001 \001(\010:\005false\0225\n%fill_addi"
1253 "tional_solutions_in_response\030\302\001 \001(\010:\005fal"
1254 "se\022\'\n\031instantiate_all_variables\030j \001(\010:\004t"
1255 "rue\0226\n(auto_detect_greater_than_at_least"
1256 "_one_of\030_ \001(\010:\004true\022(\n\031stop_after_first_"
1257 "solution\030b \001(\010:\005false\022#\n\023stop_after_pres"
1258 "olve\030\225\001 \001(\010:\005false\022+\n\033stop_after_root_pr"
1259 "opagation\030\374\001 \001(\010:\005false\022$\n\026lns_initial_d"
1260 "ifficulty\030\263\002 \001(\001:\0030.5\022-\n\037lns_initial_det"
1261 "erministic_limit\030\264\002 \001(\001:\0030.1\022\026\n\007use_lns\030"
1262 "\233\002 \001(\010:\004true\022\033\n\014use_lns_only\030e \001(\010:\005fals"
1263 "e\022\036\n\022solution_pool_size\030\301\001 \001(\005:\0013\022*\n\035sol"
1264 "ution_pool_diversity_limit\030\311\002 \001(\005:\00210\022!\n"
1265 "\025alternative_pool_size\030\305\002 \001(\005:\0011\022\033\n\014use_"
1266 "rins_lns\030\201\001 \001(\010:\004true\022#\n\024use_feasibility"
1267 "_pump\030\244\001 \001(\010:\004true\022\037\n\020use_lb_relax_lns\030\377"
1268 "\001 \001(\010:\004true\022+\n\036lb_relax_num_workers_thre"
1269 "shold\030\250\002 \001(\005:\00216\022c\n\013fp_rounding\030\245\001 \001(\01627"
1270 ".operations_research.sat.SatParameters.F"
1271 "PRoundingMethod:\024PROPAGATION_ASSISTED\022$\n"
1272 "\024diversify_lns_params\030\211\001 \001(\010:\005false\022\037\n\020r"
1273 "andomize_search\030g \001(\010:\005false\022+\n search_r"
1274 "andom_variable_pool_size\030h \001(\003:\0010\022+\n\033pus"
1275 "h_all_tasks_toward_start\030\206\002 \001(\010:\005false\022%"
1276 "\n\026use_optional_variables\030l \001(\010:\005false\022!\n"
1277 "\023use_exact_lp_reason\030m \001(\010:\004true\022\'\n\027use_"
1278 "combined_no_overlap\030\205\001 \001(\010:\005false\022*\n\036at_"
1279 "most_one_max_expansion_size\030\216\002 \001(\005:\0013\022\"\n"
1280 "\023catch_sigint_signal\030\207\001 \001(\010:\004true\022!\n\022use"
1281 "_implied_bounds\030\220\001 \001(\010:\004true\022\"\n\022polish_l"
1282 "p_solution\030\257\001 \001(\010:\005false\022#\n\023lp_primal_to"
1283 "lerance\030\212\002 \001(\001:\0051e-07\022!\n\021lp_dual_toleran"
1284 "ce\030\213\002 \001(\001:\0051e-07\022 \n\021convert_intervals\030\261\001"
1285 " \001(\010:\004true\022\032\n\016symmetry_level\030\267\001 \001(\005:\0012\022\""
1286 "\n\022use_symmetry_in_lp\030\255\002 \001(\010:\005false\022)\n\031ke"
1287 "ep_symmetry_in_presolve\030\257\002 \001(\010:\005false\0227\n"
1288 "+symmetry_detection_deterministic_time_l"
1289 "imit\030\256\002 \001(\001:\0011\022%\n\026new_linear_propagation"
1290 "\030\340\001 \001(\010:\004true\022\037\n\021linear_split_size\030\200\002 \001("
1291 "\005:\003100\022\036\n\023linearization_level\030Z \001(\005:\0011\022!"
1292 "\n\026boolean_encoding_level\030k \001(\005:\0011\022=\n0max"
1293 "_domain_size_when_encoding_eq_neq_constr"
1294 "aints\030\277\001 \001(\005:\00216\022\033\n\014max_num_cuts\030[ \001(\005:\005"
1295 "10000\022\025\n\tcut_level\030\304\001 \001(\005:\0011\022*\n\033only_add"
1296 "_cuts_at_level_zero\030\\ \001(\010:\005false\022!\n\021add_"
1297 "objective_cut\030\305\001 \001(\010:\005false\022\031\n\013add_cg_cu"
1298 "ts\030u \001(\010:\004true\022\032\n\014add_mir_cuts\030x \001(\010:\004tr"
1299 "ue\022!\n\022add_zero_half_cuts\030\251\001 \001(\010:\004true\022\036\n"
1300 "\017add_clique_cuts\030\254\001 \001(\010:\004true\022\033\n\014add_rlt"
1301 "_cuts\030\227\002 \001(\010:\004true\022\"\n\025max_all_diff_cut_s"
1302 "ize\030\224\001 \001(\005:\00264\022\037\n\020add_lin_max_cuts\030\230\001 \001("
1303 "\010:\004true\022)\n\034max_integer_rounding_scaling\030"
1304 "w \001(\005:\003600\022\'\n\031add_lp_constraints_lazily\030"
1305 "p \001(\010:\004true\022!\n\022root_lp_iterations\030\343\001 \001(\005"
1306 ":\0042000\0222\n$min_orthogonality_for_lp_const"
1307 "raints\030s \001(\001:\0040.05\022(\n\034max_cut_rounds_at_"
1308 "level_zero\030\232\001 \001(\005:\0011\022+\n\036max_consecutive_"
1309 "inactive_count\030y \001(\005:\003100\0220\n\032cut_max_act"
1310 "ive_count_value\030\233\001 \001(\001:\01310000000000\022$\n\026c"
1311 "ut_active_count_decay\030\234\001 \001(\001:\0030.8\022!\n\022cut"
1312 "_cleanup_target\030\235\001 \001(\005:\0041000\022&\n\032new_cons"
1313 "traints_batch_size\030z \001(\005:\00250\022)\n\033exploit_"
1314 "integer_lp_solution\030^ \001(\010:\004true\022%\n\027explo"
1315 "it_all_lp_solution\030t \001(\010:\004true\022%\n\025exploi"
1316 "t_best_solution\030\202\001 \001(\010:\005false\022+\n\033exploit"
1317 "_relaxation_solution\030\241\001 \001(\010:\005false\022 \n\021ex"
1318 "ploit_objective\030\203\001 \001(\010:\004true\022)\n\031detect_l"
1319 "inearized_product\030\225\002 \001(\010:\005false\0223\n#use_n"
1320 "ew_integer_conflict_resolution\030\320\002 \001(\010:\005f"
1321 "alse\022-\n\036create_1uip_boolean_during_icr\030\325"
1322 "\002 \001(\010:\004true\022\037\n\rmip_max_bound\030| \001(\001:\0101000"
1323 "0000\022\032\n\017mip_var_scaling\030} \001(\001:\0011\022&\n\026mip_"
1324 "scale_large_domain\030\341\001 \001(\010:\005false\0220\n!mip_"
1325 "automatically_scale_variables\030\246\001 \001(\010:\004tr"
1326 "ue\022\035\n\ronly_solve_ip\030\336\001 \001(\010:\005false\022#\n\024mip"
1327 "_wanted_precision\030~ \001(\001:\0051e-06\022%\n\031mip_ma"
1328 "x_activity_exponent\030\177 \001(\005:\00253\022$\n\023mip_che"
1329 "ck_precision\030\200\001 \001(\001:\0060.0001\022/\n mip_compu"
1330 "te_true_objective_bound\030\306\001 \001(\010:\004true\022\'\n\027"
1331 "mip_max_valid_magnitude\030\307\001 \001(\001:\0051e+20\022;\n"
1332 "+mip_treat_high_magnitude_bounds_as_infi"
1333 "nity\030\226\002 \001(\010:\005false\022\"\n\022mip_drop_tolerance"
1334 "\030\350\001 \001(\001:\0051e-16\022\036\n\022mip_presolve_level\030\205\002 "
1335 "\001(\005:\0012\"H\n\rVariableOrder\022\014\n\010IN_ORDER\020\000\022\024\n"
1336 "\020IN_REVERSE_ORDER\020\001\022\023\n\017IN_RANDOM_ORDER\020\002"
1337 "\"F\n\010Polarity\022\021\n\rPOLARITY_TRUE\020\000\022\022\n\016POLAR"
1338 "ITY_FALSE\020\001\022\023\n\017POLARITY_RANDOM\020\002\"J\n\035Conf"
1339 "lictMinimizationAlgorithm\022\010\n\004NONE\020\000\022\n\n\006S"
1340 "IMPLE\020\001\022\r\n\tRECURSIVE\020\002\"\004\010\003\020\003\"\233\001\n\031BinaryM"
1341 "inizationAlgorithm\022\032\n\026NO_BINARY_MINIMIZA"
1342 "TION\020\000\022 \n\034BINARY_MINIMIZATION_FROM_UIP\020\001"
1343 "\022.\n*BINARY_MINIMIZATION_FROM_UIP_AND_DEC"
1344 "ISIONS\020\005\"\004\010\002\020\002\"\004\010\003\020\003\"\004\010\004\020\004\"5\n\016ClauseOrde"
1345 "ring\022\023\n\017CLAUSE_ACTIVITY\020\000\022\016\n\nCLAUSE_LBD\020"
1346 "\001\"\206\001\n\020RestartAlgorithm\022\016\n\nNO_RESTART\020\000\022\020"
1347 "\n\014LUBY_RESTART\020\001\022\035\n\031DL_MOVING_AVERAGE_RE"
1348 "START\020\002\022\036\n\032LBD_MOVING_AVERAGE_RESTART\020\003\022"
1349 "\021\n\rFIXED_RESTART\020\004\"t\n\025MaxSatAssumptionOr"
1350 "der\022\034\n\030DEFAULT_ASSUMPTION_ORDER\020\000\022\035\n\031ORD"
1351 "ER_ASSUMPTION_BY_DEPTH\020\001\022\036\n\032ORDER_ASSUMP"
1352 "TION_BY_WEIGHT\020\002\"o\n\035MaxSatStratification"
1353 "Algorithm\022\027\n\023STRATIFICATION_NONE\020\000\022\032\n\026ST"
1354 "RATIFICATION_DESCENT\020\001\022\031\n\025STRATIFICATION"
1355 "_ASCENT\020\002\"\341\001\n\017SearchBranching\022\024\n\020AUTOMAT"
1356 "IC_SEARCH\020\000\022\020\n\014FIXED_SEARCH\020\001\022\024\n\020PORTFOL"
1357 "IO_SEARCH\020\002\022\r\n\tLP_SEARCH\020\003\022\026\n\022PSEUDO_COS"
1358 "T_SEARCH\020\004\022\'\n#PORTFOLIO_WITH_QUICK_RESTA"
1359 "RT_SEARCH\020\005\022\017\n\013HINT_SEARCH\020\006\022\030\n\024PARTIAL_"
1360 "FIXED_SEARCH\020\007\022\025\n\021RANDOMIZED_SEARCH\020\010\"\270\001"
1361 "\n\027SharedTreeSplitStrategy\022\027\n\023SPLIT_STRAT"
1362 "EGY_AUTO\020\000\022\036\n\032SPLIT_STRATEGY_DISCREPANCY"
1363 "\020\001\022\037\n\033SPLIT_STRATEGY_OBJECTIVE_LB\020\002\022 \n\034S"
1364 "PLIT_STRATEGY_BALANCED_TREE\020\003\022!\n\035SPLIT_S"
1365 "TRATEGY_FIRST_PROPOSAL\020\004\"h\n\020FPRoundingMe"
1366 "thod\022\023\n\017NEAREST_INTEGER\020\000\022\016\n\nLOCK_BASED\020"
1367 "\001\022\025\n\021ACTIVE_LOCK_BASED\020\003\022\030\n\024PROPAGATION_"
1368 "ASSISTED\020\002Bk\n\026com.google.ortools.satP\001Z:"
1369 "github.com/google/or-tools/ortools/sat/p"
1370 "roto/satparameters\252\002\022Google.OrTools.Sat"
1377 descriptor_table_protodef_ortools_2fsat_2fsat_5fparameters_2eproto,
1378 "ortools/sat/sat_parameters.proto",
1414 131072u, 32u, 8u, };
1459class SatParameters::_Internal {
1462 decltype(::std::declval<SatParameters>()._impl_._has_bits_);
1467 const ::_pbi::LazyString SatParameters::Impl_::_i_give_permission_to_break_this_code_default_default_restart_algorithms_{
1468 {{
"LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART", 65}},
1472#if defined(PROTOBUF_CUSTOM_VTABLE)
1475 : ::google::protobuf::Message(arena) {
1480PROTOBUF_NDEBUG_INLINE SatParameters::Impl_::Impl_(
1481 [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
1482 [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
const Impl_& from,
1483 [[maybe_unused]] const ::operations_research::sat::SatParameters& from_msg)
1484 : _has_bits_{from._has_bits_},
1486 restart_algorithms_{visibility, arena, from.restart_algorithms_},
1487 subsolvers_{visibility, arena, from.subsolvers_},
1488 ignore_subsolvers_{visibility, arena, from.ignore_subsolvers_},
1489 subsolver_params_{visibility, arena, from.subsolver_params_},
1490 extra_subsolvers_{visibility, arena, from.extra_subsolvers_},
1491 filter_subsolvers_{visibility, arena, from.filter_subsolvers_},
1492 default_restart_algorithms_(arena, from.default_restart_algorithms_, _i_give_permission_to_break_this_code_default_default_restart_algorithms_),
1493 name_(arena, from.name_),
1494 log_prefix_(arena, from.log_prefix_) {}
1497 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
1499#if defined(PROTOBUF_CUSTOM_VTABLE)
1502 : ::google::protobuf::Message(arena) {
1506 _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
1507 from._internal_metadata_);
1508 new (&
_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
1509 ::memcpy(
reinterpret_cast<char*
>(&
_impl_) +
1510 offsetof(Impl_, preferred_variable_order_),
1511 reinterpret_cast<const char*
>(&from._impl_) +
1512 offsetof(Impl_, preferred_variable_order_),
1513 offsetof(Impl_, max_number_of_conflicts_) -
1514 offsetof(Impl_, preferred_variable_order_) +
1515 sizeof(Impl_::max_number_of_conflicts_));
1516 ::memcpy(
reinterpret_cast<char*
>(&
_impl_) +
1517 offsetof(Impl_, random_branches_ratio_),
1518 reinterpret_cast<const char*
>(&from._impl_) +
1519 offsetof(Impl_, random_branches_ratio_),
1520 offsetof(Impl_, subsume_during_vivification_) -
1521 offsetof(Impl_, random_branches_ratio_) +
1522 sizeof(Impl_::subsume_during_vivification_));
1526PROTOBUF_NDEBUG_INLINE SatParameters::Impl_::Impl_(
1527 [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
1528 [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
1530 use_optimization_hints_{
true},
1531 use_phase_saving_{
true},
1532 use_precedences_in_disjunctive_constraint_{
true},
1535 variable_activity_decay_{0.8},
1536 max_variable_activity_value_{1e+100},
1537 clause_activity_decay_{0.999},
1538 clause_cleanup_period_{10000},
1539 glucose_decay_increment_period_{5000},
1540 max_clause_activity_value_{1e+20},
1541 glucose_max_decay_{0.95},
1542 glucose_decay_increment_{0.01},
1543 restart_period_{50},
1545 max_time_in_seconds_{std::numeric_limits<double>::infinity()},
1546 max_number_of_conflicts_{::int64_t{9223372036854775807}},
1547 restart_algorithms_{visibility, arena},
1548 subsolvers_{visibility, arena},
1549 ignore_subsolvers_{visibility, arena},
1550 subsolver_params_{visibility, arena},
1551 extra_subsolvers_{visibility, arena},
1552 filter_subsolvers_{visibility, arena},
1553 default_restart_algorithms_(arena, Impl_::_i_give_permission_to_break_this_code_default_default_restart_algorithms_),
1556 max_memory_in_mb_{::int64_t{10000}},
1558 pb_cleanup_increment_{200},
1559 pb_cleanup_ratio_{0.5},
1560 core_minimization_level_{2},
1562 presolve_bve_threshold_{500},
1563 presolve_bve_clause_weight_{3},
1564 presolve_probing_deterministic_time_limit_{30},
1565 clause_cleanup_lbd_bound_{5},
1566 restart_running_window_size_{50},
1567 restart_dl_average_ratio_{1},
1568 count_assumption_levels_in_lbd_{
true},
1569 subsumption_during_conflict_analysis_{
true},
1570 presolve_use_bva_{
true},
1571 use_disjunctive_constraint_in_cumulative_{
true},
1572 blocking_restart_window_size_{5000},
1573 blocking_restart_multiplier_{1.4},
1574 max_deterministic_time_{std::numeric_limits<double>::infinity()},
1575 restart_lbd_average_ratio_{1},
1576 presolve_bva_threshold_{1},
1577 find_multiple_cores_{
true},
1578 cp_model_presolve_{
true},
1579 presolve_blocked_clause_{
true},
1580 cover_optimization_{
true},
1581 linearization_level_{1},
1582 max_num_cuts_{10000},
1583 cp_model_use_sat_presolve_{
true},
1584 exploit_integer_lp_solution_{
true},
1585 auto_detect_greater_than_at_least_one_of_{
true},
1586 instantiate_all_variables_{
true},
1587 binary_search_num_conflicts_{-1},
1588 boolean_encoding_level_{1},
1589 cp_model_probing_level_{2},
1590 use_exact_lp_reason_{
true},
1591 add_lp_constraints_lazily_{
true},
1592 share_objective_bounds_{
true},
1593 share_level_zero_bounds_{
true},
1594 max_integer_rounding_scaling_{600},
1595 min_orthogonality_for_lp_constraints_{0.05},
1596 exploit_all_lp_solution_{
true},
1598 add_mir_cuts_{
true},
1599 use_rins_lns_{
true},
1600 max_consecutive_inactive_count_{100},
1601 pseudo_cost_reliability_threshold_{::int64_t{100}},
1602 mip_max_bound_{10000000},
1603 new_constraints_batch_size_{50},
1604 mip_max_activity_exponent_{53},
1605 mip_var_scaling_{1},
1606 mip_wanted_precision_{1e-06},
1607 mip_check_precision_{0.0001},
1608 max_presolve_iterations_{3},
1609 exploit_objective_{
true},
1610 catch_sigint_signal_{
true},
1611 use_implied_bounds_{
true},
1612 add_lin_max_cuts_{
true},
1613 merge_no_overlap_work_limit_{1000000000000},
1614 merge_at_most_one_work_limit_{100000000},
1615 presolve_substitution_level_{1},
1616 max_all_diff_cut_size_{64},
1617 hint_conflict_limit_{10},
1618 max_cut_rounds_at_level_zero_{1},
1619 cut_max_active_count_value_{10000000000},
1620 cut_active_count_decay_{0.8},
1621 absolute_gap_limit_{0.0001},
1622 cut_cleanup_target_{1000},
1624 use_sat_inprocessing_{
true},
1625 use_feasibility_pump_{
true},
1626 mip_automatically_scale_variables_{
true},
1627 add_zero_half_cuts_{
true},
1628 polarity_rephase_increment_{1000},
1629 add_clique_cuts_{
true},
1630 convert_intervals_{
true},
1631 expand_reservoir_constraints_{
true},
1632 log_to_stdout_{
true},
1634 clause_cleanup_ratio_{0.5},
1635 max_domain_size_when_encoding_eq_neq_constraints_{16},
1636 solution_pool_size_{3},
1637 mip_max_valid_magnitude_{1e+20},
1638 presolve_inclusion_work_limit_{::int64_t{100000000}},
1640 mip_compute_true_objective_bound_{
true},
1641 ignore_names_{
true},
1642 share_binary_clauses_{
true},
1643 use_dual_scheduling_heuristics_{
true},
1644 shaving_deterministic_time_in_probing_search_{0.001},
1645 shaving_search_deterministic_time_{0.1},
1646 propagation_loop_detection_factor_{10},
1647 table_compression_level_{2},
1648 root_lp_iterations_{2000},
1649 probing_deterministic_time_limit_{1},
1650 mip_drop_tolerance_{1e-16},
1651 max_size_to_create_precedence_literals_in_disjunctive_{60},
1652 shared_tree_num_workers_{-1},
1653 new_linear_propagation_{
true},
1654 infer_all_diffs_{
true},
1655 find_big_linear_overlap_{
true},
1656 feasibility_jump_enable_restarts_{
true},
1657 shared_tree_max_nodes_per_worker_{10000},
1658 feasibility_jump_decay_{0.95},
1659 feasibility_jump_var_randomization_probability_{0.05},
1660 feasibility_jump_var_perburbation_range_ratio_{0.2},
1661 violation_ls_perturbation_period_{100},
1662 linear_split_size_{100},
1663 feasibility_jump_linearization_level_{2},
1664 feasibility_jump_restart_factor_{1},
1665 violation_ls_compound_move_probability_{0.5},
1666 max_num_intervals_for_timetable_edge_finding_{100},
1667 mip_presolve_level_{2},
1668 lp_primal_tolerance_{1e-07},
1669 feasibility_jump_max_expanded_constraint_size_{500},
1670 use_lb_relax_lns_{
true},
1671 use_feasibility_jump_{
true},
1672 use_extended_probing_{
true},
1673 add_rlt_cuts_{
true},
1674 lp_dual_tolerance_{1e-07},
1675 at_most_one_max_expansion_size_{3},
1676 probing_num_combinations_limit_{20000},
1677 inprocessing_dtime_ratio_{0.2},
1678 inprocessing_probing_dtime_{1},
1679 inprocessing_minimization_dtime_{1},
1680 max_pairs_pairwise_reasoning_in_no_overlap_2d_{1250},
1681 shared_tree_worker_min_restarts_per_subtree_{1},
1682 shared_tree_open_leaves_per_worker_{2},
1683 variables_shaving_level_{-1},
1685 share_glue_clauses_{
true},
1686 shared_tree_worker_enable_trail_sharing_{
true},
1687 inprocessing_minimization_use_conflict_analysis_{
true},
1688 shaving_search_threshold_{::int64_t{64}},
1689 feasibility_jump_batch_dtime_{0.1},
1690 lb_relax_num_workers_threshold_{16},
1691 shared_tree_balance_tolerance_{1},
1692 symmetry_detection_deterministic_time_limit_{1},
1693 lns_initial_difficulty_{0.5},
1694 lns_initial_deterministic_limit_{0.1},
1695 minimize_shared_clauses_{
true},
1696 shared_tree_worker_enable_phase_sharing_{
true},
1697 remove_fixed_variables_early_{
true},
1698 use_linear3_for_no_overlap_2d_precedences_{
true},
1699 routing_cut_subset_size_for_exact_binary_relation_bound_{8},
1700 routing_cut_dp_effort_{10000000},
1701 routing_cut_max_infeasible_path_length_{6},
1702 routing_cut_subset_size_for_shortest_paths_bound_{8},
1703 max_alldiff_domain_size_{256},
1704 no_overlap_2d_boolean_relations_limit_{10},
1705 share_glue_clauses_dtime_{1},
1706 alternative_pool_size_{1},
1707 transitive_precedences_work_limit_{1000000},
1708 shared_tree_split_min_dtime_{0.1},
1709 solution_pool_diversity_limit_{10},
1710 max_backjump_levels_{50},
1711 chronological_backtrack_min_conflicts_{1000},
1712 max_domain_size_for_linear2_expansion_{8},
1713 find_clauses_that_are_exactly_one_{
true},
1714 create_1uip_boolean_during_icr_{
true},
1715 inprocessing_use_congruence_closure_{
true},
1716 extra_subsumption_during_conflict_analysis_{
true},
1717 eagerly_subsume_last_n_conflicts_{4},
1718 max_drat_time_in_seconds_{std::numeric_limits<double>::infinity()},
1719 decision_subsumption_during_conflict_analysis_{
true},
1720 subsume_during_vivification_{
true} {}
1722inline void SatParameters::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
1723 new (&
_impl_) Impl_(internal_visibility(), arena);
1724 ::memset(
reinterpret_cast<char*
>(&
_impl_) +
1725 offsetof(Impl_, preferred_variable_order_),
1727 offsetof(Impl_, use_pb_resolution_) -
1728 offsetof(Impl_, preferred_variable_order_) +
1729 sizeof(Impl_::use_pb_resolution_));
1730 ::memset(
reinterpret_cast<char*
>(&
_impl_) +
1731 offsetof(Impl_, random_branches_ratio_),
1733 offsetof(Impl_, inprocessing_use_sat_sweeping_) -
1734 offsetof(Impl_, random_branches_ratio_) +
1735 sizeof(Impl_::inprocessing_use_sat_sweeping_));
1741inline void SatParameters::SharedDtor(
MessageLite& self) {
1743 if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
1744 this_.CheckHasBitConsistency();
1746 this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
1747 ABSL_DCHECK(this_.GetArena() ==
nullptr);
1748 this_.
_impl_.default_restart_algorithms_.Destroy();
1749 this_.
_impl_.name_.Destroy();
1750 this_.
_impl_.log_prefix_.Destroy();
1754inline void* PROTOBUF_NONNULL SatParameters::PlacementNew_(
1755 const void* PROTOBUF_NONNULL,
void* PROTOBUF_NONNULL mem,
1756 ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
1759constexpr auto SatParameters::InternalNewImpl_() {
1760 constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({
1763 InternalGetArenaOffset(
1764 ::google::protobuf::Message::internal_visibility()),
1767 InternalGetArenaOffset(
1768 ::google::protobuf::Message::internal_visibility()),
1771 InternalGetArenaOffset(
1772 ::google::protobuf::Message::internal_visibility()),
1775 InternalGetArenaOffset(
1776 ::google::protobuf::Message::internal_visibility()),
1779 InternalGetArenaOffset(
1780 ::google::protobuf::Message::internal_visibility()),
1783 InternalGetArenaOffset(
1784 ::google::protobuf::Message::internal_visibility()),
1786 if (arena_bits.has_value()) {
1787 return ::google::protobuf::internal::MessageCreator::CopyInit(
1788 sizeof(SatParameters), alignof(SatParameters), *arena_bits);
1790 return ::google::protobuf::internal::MessageCreator(&SatParameters::PlacementNew_,
1791 sizeof(SatParameters),
1792 alignof(SatParameters));
1796 return ::google::protobuf::internal::ClassDataFull{
1797 ::google::protobuf::internal::ClassData{
1802 &SatParameters::MergeImpl,
1803 ::google::protobuf::Message::GetNewImpl<SatParameters>(),
1804#if defined(PROTOBUF_CUSTOM_VTABLE)
1805 &SatParameters::SharedDtor,
1812 &SatParameters::kDescriptorMethods,
1818PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
1822PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
1823SatParameters::GetClassData()
const {
1828PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
1829const ::_pbi::TcParseTable<5, 303, 12, 0, 47>
1830SatParameters::_table_ = {
1835 offsetof(
decltype(_table_), field_lookup_table),
1837 offsetof(
decltype(_table_), field_entries),
1840 offsetof(
decltype(_table_), aux_entries),
1843 ::_pbi::TcParser::GenericFallback,
1844 #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
1845 ::_pbi::TcParser::GetTable<::operations_research::sat::SatParameters>(),
1848 {::_pbi::TcParser::MiniParse, {}},
1850 {::_pbi::TcParser::FastEr0S1,
1854 {::_pbi::TcParser::FastEr0S1,
1857 {::_pbi::TcParser::MiniParse, {}},
1859 {::_pbi::TcParser::FastEr0S1,
1862 {::_pbi::TcParser::MiniParse, {}},
1863 {::_pbi::TcParser::MiniParse, {}},
1864 {::_pbi::TcParser::MiniParse, {}},
1865 {::_pbi::TcParser::MiniParse, {}},
1866 {::_pbi::TcParser::MiniParse, {}},
1867 {::_pbi::TcParser::MiniParse, {}},
1869 {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(
SatParameters,
_impl_.clause_cleanup_period_), 13>(),
1872 {::_pbi::TcParser::MiniParse, {}},
1874 {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(
SatParameters,
_impl_.clause_cleanup_target_), 1>(),
1877 {::_pbi::TcParser::MiniParse, {}},
1879 {::_pbi::TcParser::FastF64S1,
1883 {::_pbi::TcParser::FastF64S2,
1887 {::_pbi::TcParser::FastF64S2,
1891 {::_pbi::TcParser::FastF64S2,
1895 {::_pbi::TcParser::FastV8S2,
1899 {::_pbi::TcParser::FastF64S2,
1903 {::_pbi::TcParser::FastV64S2,
1907 {::_pbi::TcParser::FastF64S2,
1911 {::_pbi::TcParser::FastF64S2,
1915 {::_pbi::TcParser::FastV32S2,
1919 {::_pbi::TcParser::FastV8S2,
1923 {::_pbi::TcParser::FastV8S2,
1925 PROTOBUF_FIELD_OFFSET(
SatParameters,
_impl_.use_precedences_in_disjunctive_constraint_)}},
1927 {::_pbi::TcParser::FastV8S2,
1931 {::_pbi::TcParser::FastV8S2,
1935 {::_pbi::TcParser::FastF64S2,
1939 {::_pbi::TcParser::FastV32S2,
1943 {::_pbi::TcParser::FastV32S2,
2579 {::_pbi::TcParser::GetTable<::operations_research::sat::SatParameters>()},
2597 ::google::protobuf::internal::TSanWrite(&
_impl_);
2598 ::uint32_t cached_has_bits = 0;
2600 (void) cached_has_bits;
2602 cached_has_bits =
_impl_._has_bits_[0];
2603 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2604 ::memset(&
_impl_.preferred_variable_order_, 0,
static_cast<::
size_t>(
2605 reinterpret_cast<char*
>(&
_impl_.use_pb_resolution_) -
2606 reinterpret_cast<char*
>(&
_impl_.preferred_variable_order_)) +
sizeof(
_impl_.use_pb_resolution_));
2607 _impl_.use_optimization_hints_ =
true;
2608 _impl_.use_phase_saving_ =
true;
2609 _impl_.use_precedences_in_disjunctive_constraint_ =
true;
2611 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2612 _impl_.initial_polarity_ = 1;
2613 _impl_.minimization_algorithm_ = 2;
2614 _impl_.variable_activity_decay_ = 0.8;
2615 _impl_.max_variable_activity_value_ = 1e+100;
2616 _impl_.clause_activity_decay_ = 0.999;
2617 _impl_.clause_cleanup_period_ = 10000;
2618 _impl_.glucose_decay_increment_period_ = 5000;
2619 _impl_.max_clause_activity_value_ = 1e+20;
2621 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2622 _impl_.glucose_max_decay_ = 0.95;
2623 _impl_.glucose_decay_increment_ = 0.01;
2624 _impl_.restart_period_ = 50;
2626 _impl_.max_time_in_seconds_ = std::numeric_limits<double>::infinity();
2627 _impl_.max_number_of_conflicts_ = ::int64_t{9223372036854775807};
2628 if (CheckHasBitForRepeated(cached_has_bits, 0x00400000U)) {
2629 _impl_.restart_algorithms_.Clear();
2631 if (CheckHasBitForRepeated(cached_has_bits, 0x00800000U)) {
2632 _impl_.subsolvers_.Clear();
2635 if (BatchCheckHasBit(cached_has_bits, 0x7f000000U)) {
2636 if (CheckHasBitForRepeated(cached_has_bits, 0x01000000U)) {
2637 _impl_.ignore_subsolvers_.Clear();
2639 if (CheckHasBitForRepeated(cached_has_bits, 0x02000000U)) {
2640 _impl_.subsolver_params_.Clear();
2642 if (CheckHasBitForRepeated(cached_has_bits, 0x04000000U)) {
2643 _impl_.extra_subsolvers_.Clear();
2645 if (CheckHasBitForRepeated(cached_has_bits, 0x08000000U)) {
2646 _impl_.filter_subsolvers_.Clear();
2648 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
2649 _impl_.default_restart_algorithms_.ClearToDefault(::operations_research::sat::SatParameters::Impl_::_i_give_permission_to_break_this_code_default_default_restart_algorithms_, GetArena());
2651 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
2652 _impl_.name_.ClearNonDefaultToEmpty();
2654 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
2655 _impl_.log_prefix_.ClearNonDefaultToEmpty();
2658 _impl_.random_branches_ratio_ = 0;
2659 cached_has_bits =
_impl_._has_bits_[1];
2660 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2661 ::memset(&
_impl_.max_sat_assumption_order_, 0,
static_cast<::
size_t>(
2662 reinterpret_cast<char*
>(&
_impl_.strategy_change_increase_ratio_) -
2663 reinterpret_cast<char*
>(&
_impl_.max_sat_assumption_order_)) +
sizeof(
_impl_.strategy_change_increase_ratio_));
2665 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2666 ::memset(&
_impl_.initial_variables_activity_, 0,
static_cast<::
size_t>(
2667 reinterpret_cast<char*
>(&
_impl_.enumerate_all_solutions_) -
2668 reinterpret_cast<char*
>(&
_impl_.initial_variables_activity_)) +
sizeof(
_impl_.enumerate_all_solutions_));
2670 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2671 ::memset(&
_impl_.only_add_cuts_at_level_zero_, 0,
static_cast<::
size_t>(
2672 reinterpret_cast<char*
>(&
_impl_.exploit_best_solution_) -
2673 reinterpret_cast<char*
>(&
_impl_.only_add_cuts_at_level_zero_)) +
sizeof(
_impl_.exploit_best_solution_));
2675 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
2676 ::memset(&
_impl_.interleave_batch_size_, 0,
static_cast<::
size_t>(
2677 reinterpret_cast<char*
>(&
_impl_.stop_after_presolve_) -
2678 reinterpret_cast<char*
>(&
_impl_.interleave_batch_size_)) +
sizeof(
_impl_.stop_after_presolve_));
2680 cached_has_bits =
_impl_._has_bits_[2];
2681 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2682 ::memset(&
_impl_.exploit_relaxation_solution_, 0,
static_cast<::
size_t>(
2683 reinterpret_cast<char*
>(&
_impl_.use_probing_search_) -
2684 reinterpret_cast<char*
>(&
_impl_.exploit_relaxation_solution_)) +
sizeof(
_impl_.use_probing_search_));
2686 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2687 ::memset(&
_impl_.permute_variable_randomly_, 0,
static_cast<::
size_t>(
2688 reinterpret_cast<char*
>(&
_impl_.fix_variables_to_their_hinted_value_) -
2689 reinterpret_cast<char*
>(&
_impl_.permute_variable_randomly_)) +
sizeof(
_impl_.fix_variables_to_their_hinted_value_));
2691 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2692 ::memset(&
_impl_.fill_additional_solutions_in_response_, 0,
static_cast<::
size_t>(
2693 reinterpret_cast<char*
>(&
_impl_.detect_table_with_cost_) -
2694 reinterpret_cast<char*
>(&
_impl_.fill_additional_solutions_in_response_)) +
sizeof(
_impl_.detect_table_with_cost_));
2696 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
2697 ::memset(&
_impl_.exploit_all_precedences_, 0,
static_cast<::
size_t>(
2698 reinterpret_cast<char*
>(&
_impl_.use_ls_only_) -
2699 reinterpret_cast<char*
>(&
_impl_.exploit_all_precedences_)) +
sizeof(
_impl_.use_ls_only_));
2701 cached_has_bits =
_impl_._has_bits_[3];
2702 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2703 ::memset(&
_impl_.shared_tree_split_strategy_, 0,
static_cast<::
size_t>(
2704 reinterpret_cast<char*
>(&
_impl_.use_area_energetic_reasoning_in_no_overlap_2d_) -
2705 reinterpret_cast<char*
>(&
_impl_.shared_tree_split_strategy_)) +
sizeof(
_impl_.use_area_energetic_reasoning_in_no_overlap_2d_));
2707 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2708 ::memset(&
_impl_.detect_linearized_product_, 0,
static_cast<::
size_t>(
2709 reinterpret_cast<char*
>(&
_impl_.max_num_deterministic_batches_) -
2710 reinterpret_cast<char*
>(&
_impl_.detect_linearized_product_)) +
sizeof(
_impl_.max_num_deterministic_batches_));
2712 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2713 ::memset(&
_impl_.num_full_subsolvers_, 0,
static_cast<::
size_t>(
2714 reinterpret_cast<char*
>(&
_impl_.polarity_exploit_ls_hints_) -
2715 reinterpret_cast<char*
>(&
_impl_.num_full_subsolvers_)) +
sizeof(
_impl_.polarity_exploit_ls_hints_));
2717 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
2718 ::memset(&
_impl_.use_all_different_for_circuit_, 0,
static_cast<::
size_t>(
2719 reinterpret_cast<char*
>(&
_impl_.use_new_integer_conflict_resolution_) -
2720 reinterpret_cast<char*
>(&
_impl_.use_all_different_for_circuit_)) +
sizeof(
_impl_.use_new_integer_conflict_resolution_));
2722 cached_has_bits =
_impl_._has_bits_[4];
2723 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2724 ::memset(&
_impl_.clause_cleanup_period_increment_, 0,
static_cast<::
size_t>(
2725 reinterpret_cast<char*
>(&
_impl_.output_drat_proof_) -
2726 reinterpret_cast<char*
>(&
_impl_.clause_cleanup_period_increment_)) +
sizeof(
_impl_.output_drat_proof_));
2728 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2729 ::memset(&
_impl_.check_merged_lrat_proof_, 0,
static_cast<::
size_t>(
2730 reinterpret_cast<char*
>(&
_impl_.inprocessing_use_sat_sweeping_) -
2731 reinterpret_cast<char*
>(&
_impl_.check_merged_lrat_proof_)) +
sizeof(
_impl_.inprocessing_use_sat_sweeping_));
2732 _impl_.max_memory_in_mb_ = ::int64_t{10000};
2733 _impl_.binary_minimization_algorithm_ = 5;
2734 _impl_.pb_cleanup_increment_ = 200;
2735 _impl_.pb_cleanup_ratio_ = 0.5;
2736 _impl_.core_minimization_level_ = 2;
2737 _impl_.max_sat_stratification_ = 1;
2739 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2740 _impl_.presolve_bve_threshold_ = 500;
2741 _impl_.presolve_bve_clause_weight_ = 3;
2742 _impl_.presolve_probing_deterministic_time_limit_ = 30;
2743 _impl_.clause_cleanup_lbd_bound_ = 5;
2744 _impl_.restart_running_window_size_ = 50;
2745 _impl_.restart_dl_average_ratio_ = 1;
2746 _impl_.count_assumption_levels_in_lbd_ =
true;
2747 _impl_.subsumption_during_conflict_analysis_ =
true;
2749 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
2750 _impl_.presolve_use_bva_ =
true;
2751 _impl_.use_disjunctive_constraint_in_cumulative_ =
true;
2752 _impl_.blocking_restart_window_size_ = 5000;
2753 _impl_.blocking_restart_multiplier_ = 1.4;
2754 _impl_.max_deterministic_time_ = std::numeric_limits<double>::infinity();
2755 _impl_.restart_lbd_average_ratio_ = 1;
2756 _impl_.presolve_bva_threshold_ = 1;
2757 _impl_.find_multiple_cores_ =
true;
2759 cached_has_bits =
_impl_._has_bits_[5];
2760 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2761 _impl_.cp_model_presolve_ =
true;
2762 _impl_.presolve_blocked_clause_ =
true;
2763 _impl_.cover_optimization_ =
true;
2764 _impl_.linearization_level_ = 1;
2765 _impl_.max_num_cuts_ = 10000;
2766 _impl_.cp_model_use_sat_presolve_ =
true;
2767 _impl_.exploit_integer_lp_solution_ =
true;
2768 _impl_.auto_detect_greater_than_at_least_one_of_ =
true;
2770 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2771 _impl_.instantiate_all_variables_ =
true;
2772 _impl_.binary_search_num_conflicts_ = -1;
2773 _impl_.boolean_encoding_level_ = 1;
2774 _impl_.cp_model_probing_level_ = 2;
2775 _impl_.use_exact_lp_reason_ =
true;
2776 _impl_.add_lp_constraints_lazily_ =
true;
2777 _impl_.share_objective_bounds_ =
true;
2778 _impl_.share_level_zero_bounds_ =
true;
2780 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2781 _impl_.max_integer_rounding_scaling_ = 600;
2782 _impl_.min_orthogonality_for_lp_constraints_ = 0.05;
2783 _impl_.exploit_all_lp_solution_ =
true;
2784 _impl_.add_cg_cuts_ =
true;
2785 _impl_.add_mir_cuts_ =
true;
2786 _impl_.use_rins_lns_ =
true;
2787 _impl_.max_consecutive_inactive_count_ = 100;
2788 _impl_.pseudo_cost_reliability_threshold_ = ::int64_t{100};
2790 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
2791 _impl_.mip_max_bound_ = 10000000;
2792 _impl_.new_constraints_batch_size_ = 50;
2793 _impl_.mip_max_activity_exponent_ = 53;
2794 _impl_.mip_var_scaling_ = 1;
2795 _impl_.mip_wanted_precision_ = 1e-06;
2796 _impl_.mip_check_precision_ = 0.0001;
2797 _impl_.max_presolve_iterations_ = 3;
2798 _impl_.exploit_objective_ =
true;
2800 cached_has_bits =
_impl_._has_bits_[6];
2801 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2802 _impl_.catch_sigint_signal_ =
true;
2803 _impl_.use_implied_bounds_ =
true;
2804 _impl_.add_lin_max_cuts_ =
true;
2805 _impl_.merge_no_overlap_work_limit_ = 1000000000000;
2806 _impl_.merge_at_most_one_work_limit_ = 100000000;
2807 _impl_.presolve_substitution_level_ = 1;
2808 _impl_.max_all_diff_cut_size_ = 64;
2809 _impl_.hint_conflict_limit_ = 10;
2811 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2812 _impl_.max_cut_rounds_at_level_zero_ = 1;
2813 _impl_.cut_max_active_count_value_ = 10000000000;
2814 _impl_.cut_active_count_decay_ = 0.8;
2815 _impl_.absolute_gap_limit_ = 0.0001;
2816 _impl_.cut_cleanup_target_ = 1000;
2818 _impl_.use_sat_inprocessing_ =
true;
2819 _impl_.use_feasibility_pump_ =
true;
2821 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2822 _impl_.mip_automatically_scale_variables_ =
true;
2823 _impl_.add_zero_half_cuts_ =
true;
2824 _impl_.polarity_rephase_increment_ = 1000;
2825 _impl_.add_clique_cuts_ =
true;
2826 _impl_.convert_intervals_ =
true;
2827 _impl_.expand_reservoir_constraints_ =
true;
2828 _impl_.log_to_stdout_ =
true;
2829 _impl_.symmetry_level_ = 2;
2831 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
2832 _impl_.clause_cleanup_ratio_ = 0.5;
2833 _impl_.max_domain_size_when_encoding_eq_neq_constraints_ = 16;
2834 _impl_.solution_pool_size_ = 3;
2835 _impl_.mip_max_valid_magnitude_ = 1e+20;
2836 _impl_.presolve_inclusion_work_limit_ = ::int64_t{100000000};
2838 _impl_.mip_compute_true_objective_bound_ =
true;
2839 _impl_.ignore_names_ =
true;
2841 cached_has_bits =
_impl_._has_bits_[7];
2842 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2843 _impl_.share_binary_clauses_ =
true;
2844 _impl_.use_dual_scheduling_heuristics_ =
true;
2845 _impl_.shaving_deterministic_time_in_probing_search_ = 0.001;
2846 _impl_.shaving_search_deterministic_time_ = 0.1;
2847 _impl_.propagation_loop_detection_factor_ = 10;
2848 _impl_.table_compression_level_ = 2;
2849 _impl_.root_lp_iterations_ = 2000;
2850 _impl_.probing_deterministic_time_limit_ = 1;
2852 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2853 _impl_.mip_drop_tolerance_ = 1e-16;
2854 _impl_.max_size_to_create_precedence_literals_in_disjunctive_ = 60;
2855 _impl_.shared_tree_num_workers_ = -1;
2856 _impl_.new_linear_propagation_ =
true;
2857 _impl_.infer_all_diffs_ =
true;
2858 _impl_.find_big_linear_overlap_ =
true;
2859 _impl_.feasibility_jump_enable_restarts_ =
true;
2860 _impl_.shared_tree_max_nodes_per_worker_ = 10000;
2862 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2863 _impl_.feasibility_jump_decay_ = 0.95;
2864 _impl_.feasibility_jump_var_randomization_probability_ = 0.05;
2865 _impl_.feasibility_jump_var_perburbation_range_ratio_ = 0.2;
2866 _impl_.violation_ls_perturbation_period_ = 100;
2867 _impl_.linear_split_size_ = 100;
2868 _impl_.feasibility_jump_linearization_level_ = 2;
2869 _impl_.feasibility_jump_restart_factor_ = 1;
2870 _impl_.violation_ls_compound_move_probability_ = 0.5;
2872 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
2873 _impl_.max_num_intervals_for_timetable_edge_finding_ = 100;
2874 _impl_.mip_presolve_level_ = 2;
2875 _impl_.lp_primal_tolerance_ = 1e-07;
2876 _impl_.feasibility_jump_max_expanded_constraint_size_ = 500;
2877 _impl_.use_lb_relax_lns_ =
true;
2878 _impl_.use_feasibility_jump_ =
true;
2879 _impl_.use_extended_probing_ =
true;
2880 _impl_.add_rlt_cuts_ =
true;
2882 cached_has_bits =
_impl_._has_bits_[8];
2883 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2884 _impl_.lp_dual_tolerance_ = 1e-07;
2885 _impl_.at_most_one_max_expansion_size_ = 3;
2886 _impl_.probing_num_combinations_limit_ = 20000;
2887 _impl_.inprocessing_dtime_ratio_ = 0.2;
2888 _impl_.inprocessing_probing_dtime_ = 1;
2889 _impl_.inprocessing_minimization_dtime_ = 1;
2890 _impl_.max_pairs_pairwise_reasoning_in_no_overlap_2d_ = 1250;
2891 _impl_.shared_tree_worker_min_restarts_per_subtree_ = 1;
2893 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
2894 _impl_.shared_tree_open_leaves_per_worker_ = 2;
2895 _impl_.variables_shaving_level_ = -1;
2897 _impl_.share_glue_clauses_ =
true;
2898 _impl_.shared_tree_worker_enable_trail_sharing_ =
true;
2899 _impl_.inprocessing_minimization_use_conflict_analysis_ =
true;
2900 _impl_.shaving_search_threshold_ = ::int64_t{64};
2901 _impl_.feasibility_jump_batch_dtime_ = 0.1;
2903 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
2904 _impl_.lb_relax_num_workers_threshold_ = 16;
2905 _impl_.shared_tree_balance_tolerance_ = 1;
2906 _impl_.symmetry_detection_deterministic_time_limit_ = 1;
2907 _impl_.lns_initial_difficulty_ = 0.5;
2908 _impl_.lns_initial_deterministic_limit_ = 0.1;
2909 _impl_.minimize_shared_clauses_ =
true;
2910 _impl_.shared_tree_worker_enable_phase_sharing_ =
true;
2911 _impl_.remove_fixed_variables_early_ =
true;
2913 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
2914 _impl_.use_linear3_for_no_overlap_2d_precedences_ =
true;
2915 _impl_.routing_cut_subset_size_for_exact_binary_relation_bound_ = 8;
2916 _impl_.routing_cut_dp_effort_ = 10000000;
2917 _impl_.routing_cut_max_infeasible_path_length_ = 6;
2918 _impl_.routing_cut_subset_size_for_shortest_paths_bound_ = 8;
2919 _impl_.max_alldiff_domain_size_ = 256;
2920 _impl_.no_overlap_2d_boolean_relations_limit_ = 10;
2921 _impl_.share_glue_clauses_dtime_ = 1;
2923 cached_has_bits =
_impl_._has_bits_[9];
2924 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
2925 _impl_.alternative_pool_size_ = 1;
2926 _impl_.transitive_precedences_work_limit_ = 1000000;
2927 _impl_.shared_tree_split_min_dtime_ = 0.1;
2928 _impl_.solution_pool_diversity_limit_ = 10;
2929 _impl_.max_backjump_levels_ = 50;
2930 _impl_.chronological_backtrack_min_conflicts_ = 1000;
2931 _impl_.max_domain_size_for_linear2_expansion_ = 8;
2932 _impl_.find_clauses_that_are_exactly_one_ =
true;
2934 if (BatchCheckHasBit(cached_has_bits, 0x00007f00U)) {
2935 _impl_.create_1uip_boolean_during_icr_ =
true;
2936 _impl_.inprocessing_use_congruence_closure_ =
true;
2937 _impl_.extra_subsumption_during_conflict_analysis_ =
true;
2938 _impl_.eagerly_subsume_last_n_conflicts_ = 4;
2939 _impl_.max_drat_time_in_seconds_ = std::numeric_limits<double>::infinity();
2940 _impl_.decision_subsumption_during_conflict_analysis_ =
true;
2941 _impl_.subsume_during_vivification_ =
true;
2943 _impl_._has_bits_.Clear();
2944 _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
2947#if defined(PROTOBUF_CUSTOM_VTABLE)
2949 const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
2950 ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
2954 ::uint8_t* PROTOBUF_NONNULL target,
2955 ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream)
const {
2958 if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
2959 this_.CheckHasBitConsistency();
2962 ::uint32_t cached_has_bits = 0;
2963 (void)cached_has_bits;
2965 cached_has_bits = this_.
_impl_._has_bits_[0];
2967 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
2968 target = stream->EnsureSpace(target);
2969 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2970 1, this_._internal_preferred_variable_order(), target);
2974 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
2975 target = stream->EnsureSpace(target);
2976 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2977 2, this_._internal_initial_polarity(), target);
2981 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
2982 target = stream->EnsureSpace(target);
2983 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2984 4, this_._internal_minimization_algorithm(), target);
2988 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
2990 ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<11>(
2991 stream, this_._internal_clause_cleanup_period(), target);
2995 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
2997 ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<13>(
2998 stream, this_._internal_clause_cleanup_target(), target);
3002 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
3003 target = stream->EnsureSpace(target);
3004 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3005 15, this_._internal_variable_activity_decay(), target);
3009 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
3010 target = stream->EnsureSpace(target);
3011 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3012 16, this_._internal_max_variable_activity_value(), target);
3016 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
3017 target = stream->EnsureSpace(target);
3018 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3019 17, this_._internal_clause_activity_decay(), target);
3023 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
3024 target = stream->EnsureSpace(target);
3025 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3026 18, this_._internal_max_clause_activity_value(), target);
3030 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
3031 target = stream->EnsureSpace(target);
3032 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3033 22, this_._internal_glucose_max_decay(), target);
3037 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
3038 target = stream->EnsureSpace(target);
3039 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3040 23, this_._internal_glucose_decay_increment(), target);
3044 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
3045 target = stream->EnsureSpace(target);
3046 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3047 24, this_._internal_glucose_decay_increment_period(), target);
3051 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
3052 target = stream->EnsureSpace(target);
3053 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3054 30, this_._internal_restart_period(), target);
3058 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
3059 target = stream->EnsureSpace(target);
3060 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3061 31, this_._internal_random_seed(), target);
3065 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
3066 target = stream->EnsureSpace(target);
3067 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3068 32, this_._internal_random_branches_ratio(), target);
3071 cached_has_bits = this_.
_impl_._has_bits_[4];
3073 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
3074 target = stream->EnsureSpace(target);
3075 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3076 34, this_._internal_binary_minimization_algorithm(), target);
3079 cached_has_bits = this_.
_impl_._has_bits_[0];
3081 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
3082 target = stream->EnsureSpace(target);
3083 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3084 35, this_._internal_use_optimization_hints(), target);
3088 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
3089 target = stream->EnsureSpace(target);
3090 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3091 36, this_._internal_max_time_in_seconds(), target);
3095 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
3096 target = stream->EnsureSpace(target);
3097 target = ::_pbi::WireFormatLite::WriteInt64ToArray(
3098 37, this_._internal_max_number_of_conflicts(), target);
3101 cached_has_bits = this_.
_impl_._has_bits_[4];
3103 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
3104 target = stream->EnsureSpace(target);
3105 target = ::_pbi::WireFormatLite::WriteInt64ToArray(
3106 40, this_._internal_max_memory_in_mb(), target);
3109 cached_has_bits = this_.
_impl_._has_bits_[0];
3111 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
3112 target = stream->EnsureSpace(target);
3113 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3114 41, this_._internal_log_search_progress(), target);
3118 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
3119 target = stream->EnsureSpace(target);
3120 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3121 43, this_._internal_use_pb_resolution(), target);
3125 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
3126 target = stream->EnsureSpace(target);
3127 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3128 44, this_._internal_use_phase_saving(), target);
3132 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
3133 target = stream->EnsureSpace(target);
3134 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3135 45, this_._internal_random_polarity_ratio(), target);
3138 cached_has_bits = this_.
_impl_._has_bits_[4];
3140 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
3141 target = stream->EnsureSpace(target);
3142 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3143 46, this_._internal_pb_cleanup_increment(), target);
3147 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
3148 target = stream->EnsureSpace(target);
3149 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3150 47, this_._internal_pb_cleanup_ratio(), target);
3153 cached_has_bits = this_.
_impl_._has_bits_[1];
3155 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
3156 target = stream->EnsureSpace(target);
3157 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3158 48, this_._internal_minimize_reduction_during_pb_resolution(), target);
3161 cached_has_bits = this_.
_impl_._has_bits_[4];
3163 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
3164 target = stream->EnsureSpace(target);
3165 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3166 49, this_._internal_count_assumption_levels_in_lbd(), target);
3170 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
3171 target = stream->EnsureSpace(target);
3172 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3173 50, this_._internal_core_minimization_level(), target);
3176 cached_has_bits = this_.
_impl_._has_bits_[1];
3178 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
3179 target = stream->EnsureSpace(target);
3180 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3181 51, this_._internal_max_sat_assumption_order(), target);
3185 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
3186 target = stream->EnsureSpace(target);
3187 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3188 52, this_._internal_max_sat_reverse_assumption_order(), target);
3191 cached_has_bits = this_.
_impl_._has_bits_[4];
3193 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
3194 target = stream->EnsureSpace(target);
3195 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3196 53, this_._internal_max_sat_stratification(), target);
3200 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
3201 target = stream->EnsureSpace(target);
3202 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3203 54, this_._internal_presolve_bve_threshold(), target);
3207 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
3208 target = stream->EnsureSpace(target);
3209 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3210 55, this_._internal_presolve_bve_clause_weight(), target);
3214 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
3215 target = stream->EnsureSpace(target);
3216 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3217 56, this_._internal_subsumption_during_conflict_analysis(), target);
3221 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
3222 target = stream->EnsureSpace(target);
3223 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3224 57, this_._internal_presolve_probing_deterministic_time_limit(), target);
3228 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
3229 target = stream->EnsureSpace(target);
3230 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3231 59, this_._internal_clause_cleanup_lbd_bound(), target);
3234 cached_has_bits = this_.
_impl_._has_bits_[1];
3236 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
3237 target = stream->EnsureSpace(target);
3238 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3239 60, this_._internal_clause_cleanup_ordering(), target);
3242 cached_has_bits = this_.
_impl_._has_bits_[0];
3244 if (CheckHasBitForRepeated(cached_has_bits, 0x00400000U)) {
3245 for (
int i = 0, n = this_._internal_restart_algorithms_size();
i < n; ++
i) {
3246 target = stream->EnsureSpace(target);
3247 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3253 cached_has_bits = this_.
_impl_._has_bits_[4];
3255 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
3256 target = stream->EnsureSpace(target);
3257 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3258 62, this_._internal_restart_running_window_size(), target);
3262 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
3263 target = stream->EnsureSpace(target);
3264 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3265 63, this_._internal_restart_dl_average_ratio(), target);
3268 cached_has_bits = this_.
_impl_._has_bits_[1];
3270 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
3271 target = stream->EnsureSpace(target);
3272 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3273 64, this_._internal_use_blocking_restart(), target);
3276 cached_has_bits = this_.
_impl_._has_bits_[4];
3278 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
3279 target = stream->EnsureSpace(target);
3280 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3281 65, this_._internal_blocking_restart_window_size(), target);
3285 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
3286 target = stream->EnsureSpace(target);
3287 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3288 66, this_._internal_blocking_restart_multiplier(), target);
3292 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
3293 target = stream->EnsureSpace(target);
3294 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3295 67, this_._internal_max_deterministic_time(), target);
3298 cached_has_bits = this_.
_impl_._has_bits_[1];
3300 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
3301 target = stream->EnsureSpace(target);
3302 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3303 68, this_._internal_num_conflicts_before_strategy_changes(), target);
3307 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
3308 target = stream->EnsureSpace(target);
3309 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3310 69, this_._internal_strategy_change_increase_ratio(), target);
3313 cached_has_bits = this_.
_impl_._has_bits_[0];
3315 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
3316 const ::std::string& _s = this_._internal_default_restart_algorithms();
3317 target = stream->WriteStringMaybeAliased(70, _s, target);
3320 cached_has_bits = this_.
_impl_._has_bits_[4];
3322 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
3323 target = stream->EnsureSpace(target);
3324 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3325 71, this_._internal_restart_lbd_average_ratio(), target);
3329 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
3330 target = stream->EnsureSpace(target);
3331 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3332 72, this_._internal_presolve_use_bva(), target);
3336 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
3337 target = stream->EnsureSpace(target);
3338 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3339 73, this_._internal_presolve_bva_threshold(), target);
3342 cached_has_bits = this_.
_impl_._has_bits_[0];
3344 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
3345 target = stream->EnsureSpace(target);
3346 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3347 74, this_._internal_use_precedences_in_disjunctive_constraint(), target);
3350 cached_has_bits = this_.
_impl_._has_bits_[1];
3352 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
3353 target = stream->EnsureSpace(target);
3354 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3355 75, this_._internal_use_erwa_heuristic(), target);
3359 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
3360 target = stream->EnsureSpace(target);
3361 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3362 76, this_._internal_initial_variables_activity(), target);
3366 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
3367 target = stream->EnsureSpace(target);
3368 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3369 77, this_._internal_also_bump_variables_in_conflict_reasons(), target);
3373 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
3374 target = stream->EnsureSpace(target);
3375 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3376 78, this_._internal_use_overload_checker_in_cumulative(), target);
3380 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
3381 target = stream->EnsureSpace(target);
3382 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3383 79, this_._internal_use_timetable_edge_finding_in_cumulative(), target);
3386 cached_has_bits = this_.
_impl_._has_bits_[4];
3388 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
3389 target = stream->EnsureSpace(target);
3390 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3391 80, this_._internal_use_disjunctive_constraint_in_cumulative(), target);
3394 cached_has_bits = this_.
_impl_._has_bits_[1];
3396 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
3397 target = stream->EnsureSpace(target);
3398 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3399 82, this_._internal_search_branching(), target);
3403 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
3404 target = stream->EnsureSpace(target);
3405 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3406 83, this_._internal_optimize_with_core(), target);
3409 cached_has_bits = this_.
_impl_._has_bits_[4];
3411 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
3412 target = stream->EnsureSpace(target);
3413 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3414 84, this_._internal_find_multiple_cores(), target);
3417 cached_has_bits = this_.
_impl_._has_bits_[1];
3419 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
3420 target = stream->EnsureSpace(target);
3421 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3422 85, this_._internal_optimize_with_max_hs(), target);
3425 cached_has_bits = this_.
_impl_._has_bits_[5];
3427 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
3428 target = stream->EnsureSpace(target);
3429 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3430 86, this_._internal_cp_model_presolve(), target);
3433 cached_has_bits = this_.
_impl_._has_bits_[1];
3435 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
3436 target = stream->EnsureSpace(target);
3437 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3438 87, this_._internal_enumerate_all_solutions(), target);
3441 cached_has_bits = this_.
_impl_._has_bits_[5];
3443 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
3444 target = stream->EnsureSpace(target);
3445 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3446 88, this_._internal_presolve_blocked_clause(), target);
3450 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
3451 target = stream->EnsureSpace(target);
3452 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3453 89, this_._internal_cover_optimization(), target);
3457 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
3458 target = stream->EnsureSpace(target);
3459 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3460 90, this_._internal_linearization_level(), target);
3464 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
3465 target = stream->EnsureSpace(target);
3466 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3467 91, this_._internal_max_num_cuts(), target);
3470 cached_has_bits = this_.
_impl_._has_bits_[1];
3472 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
3473 target = stream->EnsureSpace(target);
3474 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3475 92, this_._internal_only_add_cuts_at_level_zero(), target);
3478 cached_has_bits = this_.
_impl_._has_bits_[5];
3480 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
3481 target = stream->EnsureSpace(target);
3482 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3483 93, this_._internal_cp_model_use_sat_presolve(), target);
3487 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
3488 target = stream->EnsureSpace(target);
3489 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3490 94, this_._internal_exploit_integer_lp_solution(), target);
3494 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
3495 target = stream->EnsureSpace(target);
3496 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3497 95, this_._internal_auto_detect_greater_than_at_least_one_of(), target);
3500 cached_has_bits = this_.
_impl_._has_bits_[1];
3502 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
3503 target = stream->EnsureSpace(target);
3504 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3505 98, this_._internal_stop_after_first_solution(), target);
3508 cached_has_bits = this_.
_impl_._has_bits_[5];
3510 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
3511 target = stream->EnsureSpace(target);
3512 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3513 99, this_._internal_binary_search_num_conflicts(), target);
3516 cached_has_bits = this_.
_impl_._has_bits_[1];
3518 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
3519 target = stream->EnsureSpace(target);
3520 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3521 100, this_._internal_num_search_workers(), target);
3525 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
3526 target = stream->EnsureSpace(target);
3527 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3528 101, this_._internal_use_lns_only(), target);
3532 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
3533 target = stream->EnsureSpace(target);
3534 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3535 103, this_._internal_randomize_search(), target);
3539 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
3540 target = stream->EnsureSpace(target);
3541 target = ::_pbi::WireFormatLite::WriteInt64ToArray(
3542 104, this_._internal_search_random_variable_pool_size(), target);
3545 cached_has_bits = this_.
_impl_._has_bits_[5];
3547 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
3548 target = stream->EnsureSpace(target);
3549 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3550 106, this_._internal_instantiate_all_variables(), target);
3554 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
3555 target = stream->EnsureSpace(target);
3556 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3557 107, this_._internal_boolean_encoding_level(), target);
3560 cached_has_bits = this_.
_impl_._has_bits_[1];
3562 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
3563 target = stream->EnsureSpace(target);
3564 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3565 108, this_._internal_use_optional_variables(), target);
3568 cached_has_bits = this_.
_impl_._has_bits_[5];
3570 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
3571 target = stream->EnsureSpace(target);
3572 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3573 109, this_._internal_use_exact_lp_reason(), target);
3577 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
3578 target = stream->EnsureSpace(target);
3579 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3580 110, this_._internal_cp_model_probing_level(), target);
3584 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
3585 target = stream->EnsureSpace(target);
3586 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3587 112, this_._internal_add_lp_constraints_lazily(), target);
3591 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
3592 target = stream->EnsureSpace(target);
3593 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3594 113, this_._internal_share_objective_bounds(), target);
3598 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
3599 target = stream->EnsureSpace(target);
3600 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3601 114, this_._internal_share_level_zero_bounds(), target);
3605 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
3606 target = stream->EnsureSpace(target);
3607 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3608 115, this_._internal_min_orthogonality_for_lp_constraints(), target);
3612 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
3613 target = stream->EnsureSpace(target);
3614 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3615 116, this_._internal_exploit_all_lp_solution(), target);
3619 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
3620 target = stream->EnsureSpace(target);
3621 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3622 117, this_._internal_add_cg_cuts(), target);
3626 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
3627 target = stream->EnsureSpace(target);
3628 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3629 119, this_._internal_max_integer_rounding_scaling(), target);
3633 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
3634 target = stream->EnsureSpace(target);
3635 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3636 120, this_._internal_add_mir_cuts(), target);
3640 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
3641 target = stream->EnsureSpace(target);
3642 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3643 121, this_._internal_max_consecutive_inactive_count(), target);
3647 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
3648 target = stream->EnsureSpace(target);
3649 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3650 122, this_._internal_new_constraints_batch_size(), target);
3654 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
3655 target = stream->EnsureSpace(target);
3656 target = ::_pbi::WireFormatLite::WriteInt64ToArray(
3657 123, this_._internal_pseudo_cost_reliability_threshold(), target);
3661 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
3662 target = stream->EnsureSpace(target);
3663 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3664 124, this_._internal_mip_max_bound(), target);
3668 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
3669 target = stream->EnsureSpace(target);
3670 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3671 125, this_._internal_mip_var_scaling(), target);
3675 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
3676 target = stream->EnsureSpace(target);
3677 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3678 126, this_._internal_mip_wanted_precision(), target);
3682 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
3683 target = stream->EnsureSpace(target);
3684 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3685 127, this_._internal_mip_max_activity_exponent(), target);
3689 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
3690 target = stream->EnsureSpace(target);
3691 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3692 128, this_._internal_mip_check_precision(), target);
3696 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
3697 target = stream->EnsureSpace(target);
3698 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3699 129, this_._internal_use_rins_lns(), target);
3702 cached_has_bits = this_.
_impl_._has_bits_[1];
3704 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
3705 target = stream->EnsureSpace(target);
3706 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3707 130, this_._internal_exploit_best_solution(), target);
3710 cached_has_bits = this_.
_impl_._has_bits_[5];
3712 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
3713 target = stream->EnsureSpace(target);
3714 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3715 131, this_._internal_exploit_objective(), target);
3718 cached_has_bits = this_.
_impl_._has_bits_[1];
3720 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
3721 target = stream->EnsureSpace(target);
3722 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3723 132, this_._internal_fill_tightened_domains_in_response(), target);
3727 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
3728 target = stream->EnsureSpace(target);
3729 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3730 133, this_._internal_use_combined_no_overlap(), target);
3734 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
3735 target = stream->EnsureSpace(target);
3736 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3737 134, this_._internal_interleave_batch_size(), target);
3740 cached_has_bits = this_.
_impl_._has_bits_[6];
3742 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
3743 target = stream->EnsureSpace(target);
3744 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3745 135, this_._internal_catch_sigint_signal(), target);
3748 cached_has_bits = this_.
_impl_._has_bits_[1];
3750 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
3751 target = stream->EnsureSpace(target);
3752 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3753 136, this_._internal_interleave_search(), target);
3757 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
3758 target = stream->EnsureSpace(target);
3759 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3760 137, this_._internal_diversify_lns_params(), target);
3763 cached_has_bits = this_.
_impl_._has_bits_[5];
3765 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
3766 target = stream->EnsureSpace(target);
3767 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3768 138, this_._internal_max_presolve_iterations(), target);
3771 cached_has_bits = this_.
_impl_._has_bits_[6];
3773 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
3774 target = stream->EnsureSpace(target);
3775 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3776 144, this_._internal_use_implied_bounds(), target);
3780 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
3781 target = stream->EnsureSpace(target);
3782 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3783 145, this_._internal_merge_no_overlap_work_limit(), target);
3787 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
3788 target = stream->EnsureSpace(target);
3789 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3790 146, this_._internal_merge_at_most_one_work_limit(), target);
3794 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
3795 target = stream->EnsureSpace(target);
3796 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3797 147, this_._internal_presolve_substitution_level(), target);
3801 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
3802 target = stream->EnsureSpace(target);
3803 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3804 148, this_._internal_max_all_diff_cut_size(), target);
3807 cached_has_bits = this_.
_impl_._has_bits_[1];
3809 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
3810 target = stream->EnsureSpace(target);
3811 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3812 149, this_._internal_stop_after_presolve(), target);
3816 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
3817 target = stream->EnsureSpace(target);
3818 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3819 151, this_._internal_debug_max_num_presolve_operations(), target);
3822 cached_has_bits = this_.
_impl_._has_bits_[6];
3824 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
3825 target = stream->EnsureSpace(target);
3826 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3827 152, this_._internal_add_lin_max_cuts(), target);
3831 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
3832 target = stream->EnsureSpace(target);
3833 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3834 153, this_._internal_hint_conflict_limit(), target);
3838 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
3839 target = stream->EnsureSpace(target);
3840 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3841 154, this_._internal_max_cut_rounds_at_level_zero(), target);
3845 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
3846 target = stream->EnsureSpace(target);
3847 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3848 155, this_._internal_cut_max_active_count_value(), target);
3852 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
3853 target = stream->EnsureSpace(target);
3854 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3855 156, this_._internal_cut_active_count_decay(), target);
3859 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
3860 target = stream->EnsureSpace(target);
3861 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3862 157, this_._internal_cut_cleanup_target(), target);
3866 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
3867 target = stream->EnsureSpace(target);
3868 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3869 159, this_._internal_absolute_gap_limit(), target);
3872 cached_has_bits = this_.
_impl_._has_bits_[1];
3874 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
3875 target = stream->EnsureSpace(target);
3876 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
3877 160, this_._internal_relative_gap_limit(), target);
3880 cached_has_bits = this_.
_impl_._has_bits_[2];
3882 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
3883 target = stream->EnsureSpace(target);
3884 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3885 161, this_._internal_exploit_relaxation_solution(), target);
3889 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
3890 target = stream->EnsureSpace(target);
3891 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3892 162, this_._internal_debug_postsolve_with_full_solver(), target);
3895 cached_has_bits = this_.
_impl_._has_bits_[6];
3897 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
3898 target = stream->EnsureSpace(target);
3899 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3900 163, this_._internal_use_sat_inprocessing(), target);
3904 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
3905 target = stream->EnsureSpace(target);
3906 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3907 164, this_._internal_use_feasibility_pump(), target);
3911 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
3912 target = stream->EnsureSpace(target);
3913 target = ::_pbi::WireFormatLite::WriteEnumToArray(
3914 165, this_._internal_fp_rounding(), target);
3918 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
3919 target = stream->EnsureSpace(target);
3920 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3921 166, this_._internal_mip_automatically_scale_variables(), target);
3924 cached_has_bits = this_.
_impl_._has_bits_[2];
3926 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
3927 target = stream->EnsureSpace(target);
3928 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3929 167, this_._internal_repair_hint(), target);
3932 cached_has_bits = this_.
_impl_._has_bits_[6];
3934 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
3935 target = stream->EnsureSpace(target);
3936 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
3937 168, this_._internal_polarity_rephase_increment(), target);
3941 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
3942 target = stream->EnsureSpace(target);
3943 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3944 169, this_._internal_add_zero_half_cuts(), target);
3947 cached_has_bits = this_.
_impl_._has_bits_[2];
3949 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
3950 target = stream->EnsureSpace(target);
3951 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3952 170, this_._internal_expand_alldiff_constraints(), target);
3955 cached_has_bits = this_.
_impl_._has_bits_[0];
3957 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
3958 const ::std::string& _s = this_._internal_name();
3959 target = stream->WriteStringMaybeAliased(171, _s, target);
3962 cached_has_bits = this_.
_impl_._has_bits_[6];
3964 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
3965 target = stream->EnsureSpace(target);
3966 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3967 172, this_._internal_add_clique_cuts(), target);
3970 cached_has_bits = this_.
_impl_._has_bits_[2];
3972 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
3973 target = stream->EnsureSpace(target);
3974 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3975 173, this_._internal_keep_all_feasible_solutions_in_presolve(), target);
3979 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
3980 target = stream->EnsureSpace(target);
3981 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3982 174, this_._internal_presolve_extract_integer_enforcement(), target);
3986 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
3987 target = stream->EnsureSpace(target);
3988 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3989 175, this_._internal_polish_lp_solution(), target);
3993 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
3994 target = stream->EnsureSpace(target);
3995 target = ::_pbi::WireFormatLite::WriteBoolToArray(
3996 176, this_._internal_use_probing_search(), target);
3999 cached_has_bits = this_.
_impl_._has_bits_[6];
4001 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
4002 target = stream->EnsureSpace(target);
4003 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4004 177, this_._internal_convert_intervals(), target);
4007 cached_has_bits = this_.
_impl_._has_bits_[2];
4009 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
4010 target = stream->EnsureSpace(target);
4011 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4012 178, this_._internal_permute_variable_randomly(), target);
4016 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
4017 target = stream->EnsureSpace(target);
4018 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4019 179, this_._internal_permute_presolve_constraint_order(), target);
4023 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
4024 target = stream->EnsureSpace(target);
4025 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4026 180, this_._internal_use_absl_random(), target);
4030 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
4031 target = stream->EnsureSpace(target);
4032 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4033 181, this_._internal_disable_constraint_expansion(), target);
4036 cached_has_bits = this_.
_impl_._has_bits_[6];
4038 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
4039 target = stream->EnsureSpace(target);
4040 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4041 182, this_._internal_expand_reservoir_constraints(), target);
4045 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
4046 target = stream->EnsureSpace(target);
4047 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4048 183, this_._internal_symmetry_level(), target);
4051 cached_has_bits = this_.
_impl_._has_bits_[0];
4053 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
4054 const ::std::string& _s = this_._internal_log_prefix();
4055 target = stream->WriteStringMaybeAliased(185, _s, target);
4058 cached_has_bits = this_.
_impl_._has_bits_[6];
4060 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
4061 target = stream->EnsureSpace(target);
4062 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4063 186, this_._internal_log_to_stdout(), target);
4066 cached_has_bits = this_.
_impl_._has_bits_[2];
4068 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
4069 target = stream->EnsureSpace(target);
4070 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4071 187, this_._internal_log_to_response(), target);
4075 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
4076 target = stream->EnsureSpace(target);
4077 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4078 188, this_._internal_optimize_with_lb_tree_search(), target);
4082 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
4083 target = stream->EnsureSpace(target);
4084 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4085 189, this_._internal_log_subsolver_statistics(), target);
4088 cached_has_bits = this_.
_impl_._has_bits_[6];
4090 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
4091 target = stream->EnsureSpace(target);
4092 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4093 190, this_._internal_clause_cleanup_ratio(), target);
4097 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
4098 target = stream->EnsureSpace(target);
4099 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4100 191, this_._internal_max_domain_size_when_encoding_eq_neq_constraints(), target);
4103 cached_has_bits = this_.
_impl_._has_bits_[2];
4105 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
4106 target = stream->EnsureSpace(target);
4107 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4108 192, this_._internal_fix_variables_to_their_hinted_value(), target);
4111 cached_has_bits = this_.
_impl_._has_bits_[6];
4113 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
4114 target = stream->EnsureSpace(target);
4115 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4116 193, this_._internal_solution_pool_size(), target);
4119 cached_has_bits = this_.
_impl_._has_bits_[2];
4121 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
4122 target = stream->EnsureSpace(target);
4123 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4124 194, this_._internal_fill_additional_solutions_in_response(), target);
4128 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
4129 target = stream->EnsureSpace(target);
4130 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4131 195, this_._internal_debug_crash_on_bad_hint(), target);
4134 cached_has_bits = this_.
_impl_._has_bits_[6];
4136 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
4137 target = stream->EnsureSpace(target);
4138 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4139 196, this_._internal_cut_level(), target);
4142 cached_has_bits = this_.
_impl_._has_bits_[2];
4144 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
4145 target = stream->EnsureSpace(target);
4146 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4147 197, this_._internal_add_objective_cut(), target);
4150 cached_has_bits = this_.
_impl_._has_bits_[6];
4152 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
4153 target = stream->EnsureSpace(target);
4154 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4155 198, this_._internal_mip_compute_true_objective_bound(), target);
4159 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
4160 target = stream->EnsureSpace(target);
4161 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4162 199, this_._internal_mip_max_valid_magnitude(), target);
4165 cached_has_bits = this_.
_impl_._has_bits_[2];
4167 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
4168 target = stream->EnsureSpace(target);
4169 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4170 200, this_._internal_use_timetabling_in_no_overlap_2d(), target);
4173 cached_has_bits = this_.
_impl_._has_bits_[6];
4175 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
4176 target = stream->EnsureSpace(target);
4177 target = ::_pbi::WireFormatLite::WriteInt64ToArray(
4178 201, this_._internal_presolve_inclusion_work_limit(), target);
4182 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
4183 target = stream->EnsureSpace(target);
4184 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4185 202, this_._internal_ignore_names(), target);
4188 cached_has_bits = this_.
_impl_._has_bits_[7];
4190 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
4191 target = stream->EnsureSpace(target);
4192 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4193 203, this_._internal_share_binary_clauses(), target);
4197 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
4198 target = stream->EnsureSpace(target);
4199 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4200 204, this_._internal_shaving_deterministic_time_in_probing_search(), target);
4204 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
4205 target = stream->EnsureSpace(target);
4206 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4207 205, this_._internal_shaving_search_deterministic_time(), target);
4210 cached_has_bits = this_.
_impl_._has_bits_[2];
4212 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
4213 target = stream->EnsureSpace(target);
4214 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4215 206, this_._internal_num_workers(), target);
4218 cached_has_bits = this_.
_impl_._has_bits_[0];
4220 if (CheckHasBitForRepeated(cached_has_bits, 0x00800000U)) {
4221 for (
int i = 0, n = this_._internal_subsolvers_size();
i < n; ++
i) {
4222 const auto& s = this_._internal_subsolvers().Get(
i);
4223 target = stream->WriteString(207, s, target);
4228 if (CheckHasBitForRepeated(cached_has_bits, 0x01000000U)) {
4229 for (
int i = 0, n = this_._internal_ignore_subsolvers_size();
i < n; ++
i) {
4230 const auto& s = this_._internal_ignore_subsolvers().Get(
i);
4231 target = stream->WriteString(209, s, target);
4236 if (CheckHasBitForRepeated(cached_has_bits, 0x02000000U)) {
4237 for (
unsigned i = 0, n =
static_cast<unsigned>(
4238 this_._internal_subsolver_params_size());
4240 const auto& repfield = this_._internal_subsolver_params().Get(
i);
4242 ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
4243 210, repfield, repfield.GetCachedSize(),
4248 cached_has_bits = this_.
_impl_._has_bits_[2];
4250 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
4251 target = stream->EnsureSpace(target);
4252 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4253 213, this_._internal_use_energetic_reasoning_in_no_overlap_2d(), target);
4256 cached_has_bits = this_.
_impl_._has_bits_[7];
4258 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
4259 target = stream->EnsureSpace(target);
4260 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4261 214, this_._internal_use_dual_scheduling_heuristics(), target);
4264 cached_has_bits = this_.
_impl_._has_bits_[2];
4266 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
4267 target = stream->EnsureSpace(target);
4268 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4269 215, this_._internal_use_hard_precedences_in_cumulative(), target);
4273 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
4274 target = stream->EnsureSpace(target);
4275 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4276 216, this_._internal_detect_table_with_cost(), target);
4279 cached_has_bits = this_.
_impl_._has_bits_[7];
4281 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
4282 target = stream->EnsureSpace(target);
4283 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4284 217, this_._internal_table_compression_level(), target);
4287 cached_has_bits = this_.
_impl_._has_bits_[0];
4289 if (CheckHasBitForRepeated(cached_has_bits, 0x04000000U)) {
4290 for (
int i = 0, n = this_._internal_extra_subsolvers_size();
i < n; ++
i) {
4291 const auto& s = this_._internal_extra_subsolvers().Get(
i);
4292 target = stream->WriteString(219, s, target);
4296 cached_has_bits = this_.
_impl_._has_bits_[2];
4298 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
4299 target = stream->EnsureSpace(target);
4300 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4301 220, this_._internal_exploit_all_precedences(), target);
4304 cached_has_bits = this_.
_impl_._has_bits_[7];
4306 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
4307 target = stream->EnsureSpace(target);
4308 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4309 221, this_._internal_propagation_loop_detection_factor(), target);
4312 cached_has_bits = this_.
_impl_._has_bits_[2];
4314 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
4315 target = stream->EnsureSpace(target);
4316 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4317 222, this_._internal_only_solve_ip(), target);
4321 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
4322 target = stream->EnsureSpace(target);
4323 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4324 223, this_._internal_encode_complex_linear_constraint_with_integer(), target);
4327 cached_has_bits = this_.
_impl_._has_bits_[7];
4329 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
4330 target = stream->EnsureSpace(target);
4331 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4332 224, this_._internal_new_linear_propagation(), target);
4335 cached_has_bits = this_.
_impl_._has_bits_[2];
4337 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
4338 target = stream->EnsureSpace(target);
4339 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4340 225, this_._internal_mip_scale_large_domain(), target);
4343 cached_has_bits = this_.
_impl_._has_bits_[7];
4345 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
4346 target = stream->EnsureSpace(target);
4347 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4348 226, this_._internal_probing_deterministic_time_limit(), target);
4352 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
4353 target = stream->EnsureSpace(target);
4354 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4355 227, this_._internal_root_lp_iterations(), target);
4358 cached_has_bits = this_.
_impl_._has_bits_[2];
4360 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
4361 target = stream->EnsureSpace(target);
4362 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4363 228, this_._internal_use_objective_lb_search(), target);
4366 cached_has_bits = this_.
_impl_._has_bits_[7];
4368 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
4369 target = stream->EnsureSpace(target);
4370 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4371 229, this_._internal_max_size_to_create_precedence_literals_in_disjunctive(), target);
4374 cached_has_bits = this_.
_impl_._has_bits_[2];
4376 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
4377 target = stream->EnsureSpace(target);
4378 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4379 230, this_._internal_use_strong_propagation_in_disjunctive(), target);
4382 cached_has_bits = this_.
_impl_._has_bits_[7];
4384 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
4385 target = stream->EnsureSpace(target);
4386 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4387 232, this_._internal_mip_drop_tolerance(), target);
4391 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
4392 target = stream->EnsureSpace(target);
4393 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4394 233, this_._internal_infer_all_diffs(), target);
4398 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
4399 target = stream->EnsureSpace(target);
4400 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4401 234, this_._internal_find_big_linear_overlap(), target);
4405 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
4406 target = stream->EnsureSpace(target);
4407 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4408 235, this_._internal_shared_tree_num_workers(), target);
4411 cached_has_bits = this_.
_impl_._has_bits_[2];
4413 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
4414 target = stream->EnsureSpace(target);
4415 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4416 236, this_._internal_use_shared_tree_search(), target);
4419 cached_has_bits = this_.
_impl_._has_bits_[7];
4421 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
4422 target = stream->EnsureSpace(target);
4423 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4424 238, this_._internal_shared_tree_max_nodes_per_worker(), target);
4427 cached_has_bits = this_.
_impl_._has_bits_[3];
4429 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
4430 target = stream->EnsureSpace(target);
4431 target = ::_pbi::WireFormatLite::WriteEnumToArray(
4432 239, this_._internal_shared_tree_split_strategy(), target);
4435 cached_has_bits = this_.
_impl_._has_bits_[2];
4437 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
4438 target = stream->EnsureSpace(target);
4439 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4440 240, this_._internal_use_ls_only(), target);
4443 cached_has_bits = this_.
_impl_._has_bits_[7];
4445 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
4446 target = stream->EnsureSpace(target);
4447 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4448 242, this_._internal_feasibility_jump_decay(), target);
4451 cached_has_bits = this_.
_impl_._has_bits_[3];
4453 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
4454 target = stream->EnsureSpace(target);
4455 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4456 244, this_._internal_num_violation_ls(), target);
4459 cached_has_bits = this_.
_impl_._has_bits_[7];
4461 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
4462 target = stream->EnsureSpace(target);
4463 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4464 247, this_._internal_feasibility_jump_var_randomization_probability(), target);
4468 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
4469 target = stream->EnsureSpace(target);
4470 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4471 248, this_._internal_feasibility_jump_var_perburbation_range_ratio(), target);
4475 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
4476 target = stream->EnsureSpace(target);
4477 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4478 249, this_._internal_violation_ls_perturbation_period(), target);
4482 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
4483 target = stream->EnsureSpace(target);
4484 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4485 250, this_._internal_feasibility_jump_enable_restarts(), target);
4488 cached_has_bits = this_.
_impl_._has_bits_[3];
4490 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
4491 target = stream->EnsureSpace(target);
4492 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4493 252, this_._internal_stop_after_root_propagation(), target);
4497 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
4498 target = stream->EnsureSpace(target);
4499 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4500 253, this_._internal_use_objective_shaving_search(), target);
4503 cached_has_bits = this_.
_impl_._has_bits_[7];
4505 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
4506 target = stream->EnsureSpace(target);
4507 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4508 255, this_._internal_use_lb_relax_lns(), target);
4512 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
4513 target = stream->EnsureSpace(target);
4514 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4515 256, this_._internal_linear_split_size(), target);
4519 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
4520 target = stream->EnsureSpace(target);
4521 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4522 257, this_._internal_feasibility_jump_linearization_level(), target);
4526 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
4527 target = stream->EnsureSpace(target);
4528 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4529 258, this_._internal_feasibility_jump_restart_factor(), target);
4533 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
4534 target = stream->EnsureSpace(target);
4535 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4536 259, this_._internal_violation_ls_compound_move_probability(), target);
4540 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
4541 target = stream->EnsureSpace(target);
4542 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4543 260, this_._internal_max_num_intervals_for_timetable_edge_finding(), target);
4547 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
4548 target = stream->EnsureSpace(target);
4549 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4550 261, this_._internal_mip_presolve_level(), target);
4553 cached_has_bits = this_.
_impl_._has_bits_[3];
4555 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
4556 target = stream->EnsureSpace(target);
4557 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4558 262, this_._internal_push_all_tasks_toward_start(), target);
4562 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
4563 target = stream->EnsureSpace(target);
4564 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4565 263, this_._internal_use_dynamic_precedence_in_disjunctive(), target);
4568 cached_has_bits = this_.
_impl_._has_bits_[7];
4570 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
4571 target = stream->EnsureSpace(target);
4572 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4573 264, this_._internal_feasibility_jump_max_expanded_constraint_size(), target);
4577 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
4578 target = stream->EnsureSpace(target);
4579 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4580 265, this_._internal_use_feasibility_jump(), target);
4584 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
4585 target = stream->EnsureSpace(target);
4586 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4587 266, this_._internal_lp_primal_tolerance(), target);
4590 cached_has_bits = this_.
_impl_._has_bits_[8];
4592 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
4593 target = stream->EnsureSpace(target);
4594 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4595 267, this_._internal_lp_dual_tolerance(), target);
4598 cached_has_bits = this_.
_impl_._has_bits_[3];
4600 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
4601 target = stream->EnsureSpace(target);
4602 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4603 268, this_._internal_use_dynamic_precedence_in_cumulative(), target);
4606 cached_has_bits = this_.
_impl_._has_bits_[7];
4608 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
4609 target = stream->EnsureSpace(target);
4610 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4611 269, this_._internal_use_extended_probing(), target);
4614 cached_has_bits = this_.
_impl_._has_bits_[8];
4616 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
4617 target = stream->EnsureSpace(target);
4618 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4619 270, this_._internal_at_most_one_max_expansion_size(), target);
4622 cached_has_bits = this_.
_impl_._has_bits_[3];
4624 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
4625 target = stream->EnsureSpace(target);
4626 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4627 271, this_._internal_use_area_energetic_reasoning_in_no_overlap_2d(), target);
4630 cached_has_bits = this_.
_impl_._has_bits_[8];
4632 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
4633 target = stream->EnsureSpace(target);
4634 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4635 272, this_._internal_probing_num_combinations_limit(), target);
4639 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
4640 target = stream->EnsureSpace(target);
4641 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4642 273, this_._internal_inprocessing_dtime_ratio(), target);
4646 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
4647 target = stream->EnsureSpace(target);
4648 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4649 274, this_._internal_inprocessing_probing_dtime(), target);
4653 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
4654 target = stream->EnsureSpace(target);
4655 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4656 275, this_._internal_inprocessing_minimization_dtime(), target);
4660 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
4661 target = stream->EnsureSpace(target);
4662 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4663 276, this_._internal_max_pairs_pairwise_reasoning_in_no_overlap_2d(), target);
4666 cached_has_bits = this_.
_impl_._has_bits_[3];
4668 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
4669 target = stream->EnsureSpace(target);
4670 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4671 277, this_._internal_detect_linearized_product(), target);
4675 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
4676 target = stream->EnsureSpace(target);
4677 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4678 278, this_._internal_mip_treat_high_magnitude_bounds_as_infinity(), target);
4681 cached_has_bits = this_.
_impl_._has_bits_[7];
4683 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
4684 target = stream->EnsureSpace(target);
4685 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4686 279, this_._internal_add_rlt_cuts(), target);
4689 cached_has_bits = this_.
_impl_._has_bits_[3];
4691 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
4692 target = stream->EnsureSpace(target);
4693 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4694 280, this_._internal_max_lin_max_size_for_expansion(), target);
4697 cached_has_bits = this_.
_impl_._has_bits_[8];
4699 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
4700 target = stream->EnsureSpace(target);
4701 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4702 281, this_._internal_shared_tree_open_leaves_per_worker(), target);
4706 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
4707 target = stream->EnsureSpace(target);
4708 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4709 282, this_._internal_shared_tree_worker_min_restarts_per_subtree(), target);
4713 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
4714 target = stream->EnsureSpace(target);
4715 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4716 283, this_._internal_use_lns(), target);
4719 cached_has_bits = this_.
_impl_._has_bits_[3];
4721 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
4722 target = stream->EnsureSpace(target);
4723 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4724 284, this_._internal_save_lp_basis_in_lb_tree_search(), target);
4727 cached_has_bits = this_.
_impl_._has_bits_[8];
4729 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
4730 target = stream->EnsureSpace(target);
4731 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4732 285, this_._internal_share_glue_clauses(), target);
4735 cached_has_bits = this_.
_impl_._has_bits_[3];
4737 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
4738 target = stream->EnsureSpace(target);
4739 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4740 286, this_._internal_use_conservative_scale_overload_checker(), target);
4744 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
4745 target = stream->EnsureSpace(target);
4746 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4747 287, this_._internal_encode_cumulative_as_reservoir(), target);
4751 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
4752 target = stream->EnsureSpace(target);
4753 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4754 288, this_._internal_expand_reservoir_using_circuit(), target);
4757 cached_has_bits = this_.
_impl_._has_bits_[8];
4759 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
4760 target = stream->EnsureSpace(target);
4761 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4762 289, this_._internal_variables_shaving_level(), target);
4766 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
4767 target = stream->EnsureSpace(target);
4768 target = ::_pbi::WireFormatLite::WriteInt64ToArray(
4769 290, this_._internal_shaving_search_threshold(), target);
4772 cached_has_bits = this_.
_impl_._has_bits_[3];
4774 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
4775 target = stream->EnsureSpace(target);
4776 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4777 291, this_._internal_max_num_deterministic_batches(), target);
4780 cached_has_bits = this_.
_impl_._has_bits_[8];
4782 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
4783 target = stream->EnsureSpace(target);
4784 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4785 292, this_._internal_feasibility_jump_batch_dtime(), target);
4788 cached_has_bits = this_.
_impl_._has_bits_[0];
4790 if (CheckHasBitForRepeated(cached_has_bits, 0x08000000U)) {
4791 for (
int i = 0, n = this_._internal_filter_subsolvers_size();
i < n; ++
i) {
4792 const auto& s = this_._internal_filter_subsolvers().Get(
i);
4793 target = stream->WriteString(293, s, target);
4797 cached_has_bits = this_.
_impl_._has_bits_[3];
4799 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
4800 target = stream->EnsureSpace(target);
4801 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4802 294, this_._internal_num_full_subsolvers(), target);
4805 cached_has_bits = this_.
_impl_._has_bits_[8];
4807 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
4808 target = stream->EnsureSpace(target);
4809 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4810 295, this_._internal_shared_tree_worker_enable_trail_sharing(), target);
4814 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
4815 target = stream->EnsureSpace(target);
4816 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4817 296, this_._internal_lb_relax_num_workers_threshold(), target);
4821 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
4822 target = stream->EnsureSpace(target);
4823 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4824 297, this_._internal_inprocessing_minimization_use_conflict_analysis(), target);
4827 cached_has_bits = this_.
_impl_._has_bits_[3];
4829 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
4830 target = stream->EnsureSpace(target);
4831 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4832 298, this_._internal_inprocessing_minimization_use_all_orderings(), target);
4836 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
4837 target = stream->EnsureSpace(target);
4838 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4839 299, this_._internal_use_try_edge_reasoning_in_no_overlap_2d(), target);
4842 cached_has_bits = this_.
_impl_._has_bits_[8];
4844 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
4845 target = stream->EnsureSpace(target);
4846 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4847 300, this_._internal_minimize_shared_clauses(), target);
4850 cached_has_bits = this_.
_impl_._has_bits_[3];
4852 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
4853 target = stream->EnsureSpace(target);
4854 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4855 301, this_._internal_use_symmetry_in_lp(), target);
4858 cached_has_bits = this_.
_impl_._has_bits_[8];
4860 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
4861 target = stream->EnsureSpace(target);
4862 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4863 302, this_._internal_symmetry_detection_deterministic_time_limit(), target);
4866 cached_has_bits = this_.
_impl_._has_bits_[3];
4868 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
4869 target = stream->EnsureSpace(target);
4870 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4871 303, this_._internal_keep_symmetry_in_presolve(), target);
4874 cached_has_bits = this_.
_impl_._has_bits_[8];
4876 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
4877 target = stream->EnsureSpace(target);
4878 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4879 304, this_._internal_shared_tree_worker_enable_phase_sharing(), target);
4883 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
4884 target = stream->EnsureSpace(target);
4885 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4886 305, this_._internal_shared_tree_balance_tolerance(), target);
4889 cached_has_bits = this_.
_impl_._has_bits_[3];
4891 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
4892 target = stream->EnsureSpace(target);
4893 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4894 306, this_._internal_debug_crash_if_presolve_breaks_hint(), target);
4897 cached_has_bits = this_.
_impl_._has_bits_[8];
4899 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
4900 target = stream->EnsureSpace(target);
4901 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4902 307, this_._internal_lns_initial_difficulty(), target);
4906 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
4907 target = stream->EnsureSpace(target);
4908 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4909 308, this_._internal_lns_initial_deterministic_limit(), target);
4912 cached_has_bits = this_.
_impl_._has_bits_[3];
4914 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
4915 target = stream->EnsureSpace(target);
4916 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4917 309, this_._internal_polarity_exploit_ls_hints(), target);
4920 cached_has_bits = this_.
_impl_._has_bits_[8];
4922 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
4923 target = stream->EnsureSpace(target);
4924 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4925 310, this_._internal_remove_fixed_variables_early(), target);
4928 cached_has_bits = this_.
_impl_._has_bits_[3];
4930 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
4931 target = stream->EnsureSpace(target);
4932 target = ::_pbi::WireFormatLite::WriteBoolToArray(
4933 311, this_._internal_use_all_different_for_circuit(), target);
4937 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
4938 target = stream->EnsureSpace(target);
4939 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4940 312, this_._internal_routing_cut_subset_size_for_binary_relation_bound(), target);
4944 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
4945 target = stream->EnsureSpace(target);
4946 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4947 313, this_._internal_routing_cut_subset_size_for_tight_binary_relation_bound(), target);
4950 cached_has_bits = this_.
_impl_._has_bits_[8];
4952 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
4953 target = stream->EnsureSpace(target);
4954 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
4955 314, this_._internal_routing_cut_dp_effort(), target);
4958 cached_has_bits = this_.
_impl_._has_bits_[3];
4960 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
4961 target = stream->EnsureSpace(target);
4962 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4963 315, this_._internal_maximum_regions_to_split_in_disconnected_no_overlap_2d(), target);
4966 cached_has_bits = this_.
_impl_._has_bits_[8];
4968 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
4969 target = stream->EnsureSpace(target);
4970 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4971 316, this_._internal_routing_cut_subset_size_for_exact_binary_relation_bound(), target);
4975 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
4976 target = stream->EnsureSpace(target);
4977 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4978 317, this_._internal_routing_cut_max_infeasible_path_length(), target);
4982 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
4983 target = stream->EnsureSpace(target);
4984 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4985 318, this_._internal_routing_cut_subset_size_for_shortest_paths_bound(), target);
4989 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
4990 target = stream->EnsureSpace(target);
4991 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4992 320, this_._internal_max_alldiff_domain_size(), target);
4996 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
4997 target = stream->EnsureSpace(target);
4998 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
4999 321, this_._internal_no_overlap_2d_boolean_relations_limit(), target);
5003 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
5004 target = stream->EnsureSpace(target);
5005 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
5006 322, this_._internal_share_glue_clauses_dtime(), target);
5010 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
5011 target = stream->EnsureSpace(target);
5012 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5013 323, this_._internal_use_linear3_for_no_overlap_2d_precedences(), target);
5016 cached_has_bits = this_.
_impl_._has_bits_[3];
5018 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
5019 target = stream->EnsureSpace(target);
5020 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5021 324, this_._internal_filter_sat_postsolve_clauses(), target);
5024 cached_has_bits = this_.
_impl_._has_bits_[9];
5026 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
5027 target = stream->EnsureSpace(target);
5028 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5029 325, this_._internal_alternative_pool_size(), target);
5032 cached_has_bits = this_.
_impl_._has_bits_[3];
5034 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
5035 target = stream->EnsureSpace(target);
5036 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5037 326, this_._internal_share_linear2_bounds(), target);
5040 cached_has_bits = this_.
_impl_._has_bits_[9];
5042 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
5043 target = stream->EnsureSpace(target);
5044 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5045 327, this_._internal_transitive_precedences_work_limit(), target);
5049 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
5050 target = stream->EnsureSpace(target);
5051 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
5052 328, this_._internal_shared_tree_split_min_dtime(), target);
5056 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
5057 target = stream->EnsureSpace(target);
5058 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5059 329, this_._internal_solution_pool_diversity_limit(), target);
5062 cached_has_bits = this_.
_impl_._has_bits_[3];
5064 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
5065 target = stream->EnsureSpace(target);
5066 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5067 330, this_._internal_use_chronological_backtracking(), target);
5070 cached_has_bits = this_.
_impl_._has_bits_[9];
5072 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
5073 target = stream->EnsureSpace(target);
5074 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5075 331, this_._internal_max_backjump_levels(), target);
5079 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
5080 target = stream->EnsureSpace(target);
5081 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5082 332, this_._internal_chronological_backtrack_min_conflicts(), target);
5086 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
5087 target = stream->EnsureSpace(target);
5088 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5089 333, this_._internal_find_clauses_that_are_exactly_one(), target);
5092 cached_has_bits = this_.
_impl_._has_bits_[3];
5094 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
5095 target = stream->EnsureSpace(target);
5096 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5097 335, this_._internal_load_at_most_ones_in_sat_presolve(), target);
5101 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
5102 target = stream->EnsureSpace(target);
5103 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5104 336, this_._internal_use_new_integer_conflict_resolution(), target);
5107 cached_has_bits = this_.
_impl_._has_bits_[4];
5109 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
5110 target = stream->EnsureSpace(target);
5111 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5112 337, this_._internal_clause_cleanup_period_increment(), target);
5116 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
5117 target = stream->EnsureSpace(target);
5118 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5119 339, this_._internal_debug_crash_if_lrat_check_fails(), target);
5122 cached_has_bits = this_.
_impl_._has_bits_[9];
5124 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5125 target = stream->EnsureSpace(target);
5126 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5127 340, this_._internal_max_domain_size_for_linear2_expansion(), target);
5131 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
5132 target = stream->EnsureSpace(target);
5133 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5134 341, this_._internal_create_1uip_boolean_during_icr(), target);
5138 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
5139 target = stream->EnsureSpace(target);
5140 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5141 342, this_._internal_inprocessing_use_congruence_closure(), target);
5145 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
5146 target = stream->EnsureSpace(target);
5147 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5148 343, this_._internal_eagerly_subsume_last_n_conflicts(), target);
5151 cached_has_bits = this_.
_impl_._has_bits_[4];
5153 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
5154 target = stream->EnsureSpace(target);
5155 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5156 344, this_._internal_check_lrat_proof(), target);
5160 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
5161 target = stream->EnsureSpace(target);
5162 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5163 345, this_._internal_output_lrat_proof(), target);
5167 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
5168 target = stream->EnsureSpace(target);
5169 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5170 346, this_._internal_check_drat_proof(), target);
5174 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
5175 target = stream->EnsureSpace(target);
5176 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5177 347, this_._internal_output_drat_proof(), target);
5180 cached_has_bits = this_.
_impl_._has_bits_[9];
5182 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
5183 target = stream->EnsureSpace(target);
5184 target = ::_pbi::WireFormatLite::WriteDoubleToArray(
5185 348, this_._internal_max_drat_time_in_seconds(), target);
5188 cached_has_bits = this_.
_impl_._has_bits_[4];
5190 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
5191 target = stream->EnsureSpace(target);
5192 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5193 349, this_._internal_clause_cleanup_lbd_tier1(), target);
5197 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5198 target = stream->EnsureSpace(target);
5199 target = ::_pbi::WireFormatLite::WriteInt32ToArray(
5200 350, this_._internal_clause_cleanup_lbd_tier2(), target);
5203 cached_has_bits = this_.
_impl_._has_bits_[9];
5205 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
5206 target = stream->EnsureSpace(target);
5207 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5208 351, this_._internal_extra_subsumption_during_conflict_analysis(), target);
5211 cached_has_bits = this_.
_impl_._has_bits_[4];
5213 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
5214 target = stream->EnsureSpace(target);
5215 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5216 352, this_._internal_check_merged_lrat_proof(), target);
5219 cached_has_bits = this_.
_impl_._has_bits_[9];
5221 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
5222 target = stream->EnsureSpace(target);
5223 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5224 353, this_._internal_decision_subsumption_during_conflict_analysis(), target);
5227 cached_has_bits = this_.
_impl_._has_bits_[4];
5229 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
5230 target = stream->EnsureSpace(target);
5231 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5232 354, this_._internal_inprocessing_use_sat_sweeping(), target);
5235 cached_has_bits = this_.
_impl_._has_bits_[9];
5237 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
5238 target = stream->EnsureSpace(target);
5239 target = ::_pbi::WireFormatLite::WriteBoolToArray(
5240 355, this_._internal_subsume_during_vivification(), target);
5243 if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
5245 ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
5246 this_._internal_metadata_.
unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
5252#if defined(PROTOBUF_CUSTOM_VTABLE)
5260 ::size_t total_size = 0;
5262 ::uint32_t cached_has_bits = 0;
5264 (void)cached_has_bits;
5266 ::_pbi::Prefetch5LinesFrom7Lines(&this_);
5267 cached_has_bits = this_.
_impl_._has_bits_[0];
5268 total_size += ::absl::popcount(0x80139804U & cached_has_bits) * 10;
5269 total_size +=
static_cast<bool>(0x00000400U & cached_has_bits) * 9;
5270 total_size += ::absl::popcount(0x000000f8U & cached_has_bits) * 3;
5271 if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
5273 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
5275 ::_pbi::WireFormatLite::EnumSize(this_._internal_preferred_variable_order());
5278 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
5279 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
5280 this_._internal_clause_cleanup_target());
5283 if (BatchCheckHasBit(cached_has_bits, 0x00006300U)) {
5285 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
5287 ::_pbi::WireFormatLite::EnumSize(this_._internal_initial_polarity());
5290 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
5292 ::_pbi::WireFormatLite::EnumSize(this_._internal_minimization_algorithm());
5295 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
5296 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
5297 this_._internal_clause_cleanup_period());
5300 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
5301 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5302 this_._internal_glucose_decay_increment_period());
5305 if (BatchCheckHasBit(cached_has_bits, 0x00ec0000U)) {
5307 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
5308 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5309 this_._internal_restart_period());
5312 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
5313 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5314 this_._internal_random_seed());
5317 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
5318 total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
5319 this_._internal_max_number_of_conflicts());
5322 if (CheckHasBitForRepeated(cached_has_bits, 0x00400000U)) {
5323 ::size_t data_size =
5324 ::_pbi::WireFormatLite::EnumSize(this_._internal_restart_algorithms());
5325 ::size_t tag_size = ::size_t{2} *
5326 ::_pbi::FromIntSize(this_._internal_restart_algorithms_size());
5327 total_size += data_size + tag_size;
5330 if (CheckHasBitForRepeated(cached_has_bits, 0x00800000U)) {
5332 2 * ::google::protobuf::internal::FromIntSize(this_._internal_subsolvers().size());
5333 for (
int i = 0, n = this_._internal_subsolvers().size();
i < n; ++
i) {
5334 total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
5335 this_._internal_subsolvers().Get(
i));
5339 if (BatchCheckHasBit(cached_has_bits, 0x7f000000U)) {
5341 if (CheckHasBitForRepeated(cached_has_bits, 0x01000000U)) {
5343 2 * ::google::protobuf::internal::FromIntSize(this_._internal_ignore_subsolvers().size());
5344 for (
int i = 0, n = this_._internal_ignore_subsolvers().size();
i < n; ++
i) {
5345 total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
5346 this_._internal_ignore_subsolvers().Get(
i));
5350 if (CheckHasBitForRepeated(cached_has_bits, 0x02000000U)) {
5351 total_size += 2UL * this_._internal_subsolver_params_size();
5352 for (
const auto& msg : this_._internal_subsolver_params()) {
5353 total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
5357 if (CheckHasBitForRepeated(cached_has_bits, 0x04000000U)) {
5359 2 * ::google::protobuf::internal::FromIntSize(this_._internal_extra_subsolvers().size());
5360 for (
int i = 0, n = this_._internal_extra_subsolvers().size();
i < n; ++
i) {
5361 total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
5362 this_._internal_extra_subsolvers().Get(
i));
5366 if (CheckHasBitForRepeated(cached_has_bits, 0x08000000U)) {
5368 2 * ::google::protobuf::internal::FromIntSize(this_._internal_filter_subsolvers().size());
5369 for (
int i = 0, n = this_._internal_filter_subsolvers().size();
i < n; ++
i) {
5370 total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
5371 this_._internal_filter_subsolvers().Get(
i));
5375 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
5376 total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize(
5377 this_._internal_default_restart_algorithms());
5380 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
5381 total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize(
5382 this_._internal_name());
5385 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
5386 total_size += 2 + ::google::protobuf::internal::WireFormatLite::StringSize(
5387 this_._internal_log_prefix());
5390 cached_has_bits = this_.
_impl_._has_bits_[1];
5391 total_size += ::absl::popcount(0x40000180U & cached_has_bits) * 10;
5392 total_size += ::absl::popcount(0x9ef3de1eU & cached_has_bits) * 3;
5393 if (BatchCheckHasBit(cached_has_bits, 0x00000061U)) {
5395 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
5397 ::_pbi::WireFormatLite::EnumSize(this_._internal_max_sat_assumption_order());
5400 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
5402 ::_pbi::WireFormatLite::EnumSize(this_._internal_clause_cleanup_ordering());
5405 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5406 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5407 this_._internal_num_conflicts_before_strategy_changes());
5412 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
5414 ::_pbi::WireFormatLite::EnumSize(this_._internal_search_branching());
5417 if (BatchCheckHasBit(cached_has_bits, 0x000c0000U)) {
5419 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
5420 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5421 this_._internal_num_search_workers());
5424 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
5425 total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
5426 this_._internal_search_random_variable_pool_size());
5429 if (BatchCheckHasBit(cached_has_bits, 0x21000000U)) {
5431 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
5432 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5433 this_._internal_interleave_batch_size());
5436 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
5437 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5438 this_._internal_debug_max_num_presolve_operations());
5441 cached_has_bits = this_.
_impl_._has_bits_[2];
5442 total_size += ::absl::popcount(0xfff7ffffU & cached_has_bits) * 3;
5445 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
5446 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5447 this_._internal_num_workers());
5450 cached_has_bits = this_.
_impl_._has_bits_[3];
5451 total_size += ::absl::popcount(0xf3de7bfcU & cached_has_bits) * 3;
5452 if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
5454 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
5456 ::_pbi::WireFormatLite::EnumSize(this_._internal_shared_tree_split_strategy());
5459 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
5460 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5461 this_._internal_num_violation_ls());
5464 if (BatchCheckHasBit(cached_has_bits, 0x00008400U)) {
5466 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
5467 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5468 this_._internal_max_lin_max_size_for_expansion());
5471 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
5472 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5473 this_._internal_max_num_deterministic_batches());
5476 if (BatchCheckHasBit(cached_has_bits, 0x00210000U)) {
5478 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
5479 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5480 this_._internal_num_full_subsolvers());
5483 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
5484 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5485 this_._internal_routing_cut_subset_size_for_binary_relation_bound());
5488 if (BatchCheckHasBit(cached_has_bits, 0x0c000000U)) {
5490 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
5491 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5492 this_._internal_routing_cut_subset_size_for_tight_binary_relation_bound());
5495 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
5496 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5497 this_._internal_maximum_regions_to_split_in_disconnected_no_overlap_2d());
5500 cached_has_bits = this_.
_impl_._has_bits_[4];
5501 total_size += ::absl::popcount(0x38242000U & cached_has_bits) * 10;
5502 total_size += ::absl::popcount(0x83c0039eU & cached_has_bits) * 3;
5503 if (BatchCheckHasBit(cached_has_bits, 0x00000061U)) {
5505 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
5506 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5507 this_._internal_clause_cleanup_period_increment());
5510 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
5511 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5512 this_._internal_clause_cleanup_lbd_tier1());
5515 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5516 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5517 this_._internal_clause_cleanup_lbd_tier2());
5520 if (BatchCheckHasBit(cached_has_bits, 0x0000dc00U)) {
5522 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
5523 total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
5524 this_._internal_max_memory_in_mb());
5527 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
5529 ::_pbi::WireFormatLite::EnumSize(this_._internal_binary_minimization_algorithm());
5532 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
5533 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5534 this_._internal_pb_cleanup_increment());
5537 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
5538 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5539 this_._internal_core_minimization_level());
5542 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
5544 ::_pbi::WireFormatLite::EnumSize(this_._internal_max_sat_stratification());
5547 if (BatchCheckHasBit(cached_has_bits, 0x001b0000U)) {
5549 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
5550 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5551 this_._internal_presolve_bve_threshold());
5554 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
5555 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5556 this_._internal_presolve_bve_clause_weight());
5559 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
5560 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5561 this_._internal_clause_cleanup_lbd_bound());
5564 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
5565 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5566 this_._internal_restart_running_window_size());
5569 if (BatchCheckHasBit(cached_has_bits, 0x44000000U)) {
5571 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
5572 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5573 this_._internal_blocking_restart_window_size());
5576 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
5577 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5578 this_._internal_presolve_bva_threshold());
5581 cached_has_bits = this_.
_impl_._has_bits_[5];
5582 total_size += ::absl::popcount(0x39020000U & cached_has_bits) * 10;
5583 total_size += ::absl::popcount(0x803cf1e7U & cached_has_bits) * 3;
5584 if (BatchCheckHasBit(cached_has_bits, 0x00000018U)) {
5586 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
5587 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5588 this_._internal_linearization_level());
5591 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
5592 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5593 this_._internal_max_num_cuts());
5596 if (BatchCheckHasBit(cached_has_bits, 0x00000e00U)) {
5598 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
5599 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5600 this_._internal_binary_search_num_conflicts());
5603 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
5604 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5605 this_._internal_boolean_encoding_level());
5608 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
5609 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5610 this_._internal_cp_model_probing_level());
5613 if (BatchCheckHasBit(cached_has_bits, 0x00c10000U)) {
5615 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
5616 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5617 this_._internal_max_integer_rounding_scaling());
5620 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
5621 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5622 this_._internal_max_consecutive_inactive_count());
5625 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
5626 total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
5627 this_._internal_pseudo_cost_reliability_threshold());
5630 if (BatchCheckHasBit(cached_has_bits, 0x46000000U)) {
5632 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
5633 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5634 this_._internal_new_constraints_batch_size());
5637 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
5638 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5639 this_._internal_mip_max_activity_exponent());
5642 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
5643 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5644 this_._internal_max_presolve_iterations());
5647 cached_has_bits = this_.
_impl_._has_bits_[6];
5648 total_size += ::absl::popcount(0x09000e18U & cached_has_bits) * 10;
5649 total_size += ::absl::popcount(0xc07bc007U & cached_has_bits) * 3;
5650 if (BatchCheckHasBit(cached_has_bits, 0x000000e0U)) {
5652 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
5653 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5654 this_._internal_presolve_substitution_level());
5657 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5658 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5659 this_._internal_max_all_diff_cut_size());
5662 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
5663 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5664 this_._internal_hint_conflict_limit());
5667 if (BatchCheckHasBit(cached_has_bits, 0x00003100U)) {
5669 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
5670 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5671 this_._internal_max_cut_rounds_at_level_zero());
5674 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
5675 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5676 this_._internal_cut_cleanup_target());
5679 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
5681 ::_pbi::WireFormatLite::EnumSize(this_._internal_fp_rounding());
5684 if (BatchCheckHasBit(cached_has_bits, 0x00840000U)) {
5686 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
5687 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5688 this_._internal_polarity_rephase_increment());
5691 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
5692 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5693 this_._internal_symmetry_level());
5696 if (BatchCheckHasBit(cached_has_bits, 0x36000000U)) {
5698 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
5699 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5700 this_._internal_max_domain_size_when_encoding_eq_neq_constraints());
5703 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
5704 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5705 this_._internal_solution_pool_size());
5708 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
5709 total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
5710 this_._internal_presolve_inclusion_work_limit());
5713 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
5714 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5715 this_._internal_cut_level());
5718 cached_has_bits = this_.
_impl_._has_bits_[7];
5719 total_size += ::absl::popcount(0x0487019cU & cached_has_bits) * 10;
5720 total_size += ::absl::popcount(0xf0007803U & cached_has_bits) * 3;
5721 if (BatchCheckHasBit(cached_has_bits, 0x00000060U)) {
5723 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
5724 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5725 this_._internal_table_compression_level());
5728 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5729 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5730 this_._internal_root_lp_iterations());
5733 if (BatchCheckHasBit(cached_has_bits, 0x00008600U)) {
5735 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
5736 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5737 this_._internal_max_size_to_create_precedence_literals_in_disjunctive());
5740 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
5741 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5742 this_._internal_shared_tree_num_workers());
5745 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
5746 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5747 this_._internal_shared_tree_max_nodes_per_worker());
5750 if (BatchCheckHasBit(cached_has_bits, 0x00780000U)) {
5752 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
5753 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5754 this_._internal_violation_ls_perturbation_period());
5757 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
5758 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5759 this_._internal_linear_split_size());
5762 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
5763 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5764 this_._internal_feasibility_jump_linearization_level());
5767 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
5768 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5769 this_._internal_feasibility_jump_restart_factor());
5772 if (BatchCheckHasBit(cached_has_bits, 0x0b000000U)) {
5774 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
5775 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5776 this_._internal_max_num_intervals_for_timetable_edge_finding());
5779 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
5780 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5781 this_._internal_mip_presolve_level());
5784 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
5785 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5786 this_._internal_feasibility_jump_max_expanded_constraint_size());
5789 cached_has_bits = this_.
_impl_._has_bits_[8];
5790 total_size += ::absl::popcount(0x841c8139U & cached_has_bits) * 10;
5791 total_size += ::absl::popcount(0x01e03c00U & cached_has_bits) * 3;
5792 if (BatchCheckHasBit(cached_has_bits, 0x000000c6U)) {
5794 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
5795 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5796 this_._internal_at_most_one_max_expansion_size());
5799 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
5800 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5801 this_._internal_probing_num_combinations_limit());
5804 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5805 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5806 this_._internal_max_pairs_pairwise_reasoning_in_no_overlap_2d());
5809 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
5810 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5811 this_._internal_shared_tree_worker_min_restarts_per_subtree());
5814 if (BatchCheckHasBit(cached_has_bits, 0x00004200U)) {
5816 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
5817 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5818 this_._internal_variables_shaving_level());
5821 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
5822 total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
5823 this_._internal_shaving_search_threshold());
5826 if (BatchCheckHasBit(cached_has_bits, 0x00030000U)) {
5828 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
5829 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5830 this_._internal_lb_relax_num_workers_threshold());
5833 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
5834 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5835 this_._internal_shared_tree_balance_tolerance());
5838 if (BatchCheckHasBit(cached_has_bits, 0x7a000000U)) {
5840 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
5841 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5842 this_._internal_routing_cut_subset_size_for_exact_binary_relation_bound());
5845 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
5846 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5847 this_._internal_routing_cut_max_infeasible_path_length());
5850 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
5851 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5852 this_._internal_routing_cut_subset_size_for_shortest_paths_bound());
5855 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
5856 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5857 this_._internal_max_alldiff_domain_size());
5860 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
5861 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5862 this_._internal_no_overlap_2d_boolean_relations_limit());
5865 cached_has_bits = this_.
_impl_._has_bits_[9];
5866 total_size += ::absl::popcount(0x00001004U & cached_has_bits) * 10;
5867 total_size += ::absl::popcount(0x00006780U & cached_has_bits) * 3;
5868 if (BatchCheckHasBit(cached_has_bits, 0x0000007bU)) {
5870 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
5871 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5872 this_._internal_alternative_pool_size());
5875 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
5876 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5877 this_._internal_transitive_precedences_work_limit());
5880 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
5881 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5882 this_._internal_solution_pool_diversity_limit());
5885 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
5886 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5887 this_._internal_max_backjump_levels());
5890 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
5891 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5892 this_._internal_chronological_backtrack_min_conflicts());
5895 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5896 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5897 this_._internal_max_domain_size_for_linear2_expansion());
5902 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
5903 total_size += 2 + ::_pbi::WireFormatLite::Int32Size(
5904 this_._internal_eagerly_subsume_last_n_conflicts());
5907 return this_.MaybeComputeUnknownFieldsSize(total_size,
5908 &this_.
_impl_._cached_size_);
5911void SatParameters::MergeImpl(::google::protobuf::MessageLite& to_msg,
5912 const ::google::protobuf::MessageLite& from_msg) {
5916 if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
5917 from.CheckHasBitConsistency();
5921 ABSL_DCHECK_NE(&from, _this);
5922 ::uint32_t cached_has_bits = 0;
5923 (void)cached_has_bits;
5925 cached_has_bits = from._impl_._has_bits_[0];
5926 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
5927 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
5928 _this->_impl_.preferred_variable_order_ = from._impl_.preferred_variable_order_;
5930 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
5931 _this->_impl_.clause_cleanup_target_ = from._impl_.clause_cleanup_target_;
5933 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
5934 _this->_impl_.random_polarity_ratio_ = from._impl_.random_polarity_ratio_;
5936 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
5937 _this->_impl_.log_search_progress_ = from._impl_.log_search_progress_;
5939 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
5940 _this->_impl_.use_pb_resolution_ = from._impl_.use_pb_resolution_;
5942 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
5943 _this->_impl_.use_optimization_hints_ = from._impl_.use_optimization_hints_;
5945 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
5946 _this->_impl_.use_phase_saving_ = from._impl_.use_phase_saving_;
5948 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
5949 _this->_impl_.use_precedences_in_disjunctive_constraint_ = from._impl_.use_precedences_in_disjunctive_constraint_;
5952 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
5953 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
5954 _this->_impl_.initial_polarity_ = from._impl_.initial_polarity_;
5956 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
5957 _this->_impl_.minimization_algorithm_ = from._impl_.minimization_algorithm_;
5959 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
5960 _this->_impl_.variable_activity_decay_ = from._impl_.variable_activity_decay_;
5962 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
5963 _this->_impl_.max_variable_activity_value_ = from._impl_.max_variable_activity_value_;
5965 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
5966 _this->_impl_.clause_activity_decay_ = from._impl_.clause_activity_decay_;
5968 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
5969 _this->_impl_.clause_cleanup_period_ = from._impl_.clause_cleanup_period_;
5971 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
5972 _this->_impl_.glucose_decay_increment_period_ = from._impl_.glucose_decay_increment_period_;
5974 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
5975 _this->_impl_.max_clause_activity_value_ = from._impl_.max_clause_activity_value_;
5978 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
5979 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
5980 _this->_impl_.glucose_max_decay_ = from._impl_.glucose_max_decay_;
5982 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
5983 _this->_impl_.glucose_decay_increment_ = from._impl_.glucose_decay_increment_;
5985 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
5986 _this->_impl_.restart_period_ = from._impl_.restart_period_;
5988 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
5989 _this->_impl_.random_seed_ = from._impl_.random_seed_;
5991 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
5992 _this->_impl_.max_time_in_seconds_ = from._impl_.max_time_in_seconds_;
5994 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
5995 _this->_impl_.max_number_of_conflicts_ = from._impl_.max_number_of_conflicts_;
5997 if (CheckHasBitForRepeated(cached_has_bits, 0x00400000U)) {
5998 _this->_internal_mutable_restart_algorithms()->MergeFrom(from._internal_restart_algorithms());
6000 if (CheckHasBitForRepeated(cached_has_bits, 0x00800000U)) {
6001 _this->_internal_mutable_subsolvers()->InternalMergeFromWithArena(
6002 ::google::protobuf::MessageLite::internal_visibility(), arena,
6003 from._internal_subsolvers());
6006 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6007 if (CheckHasBitForRepeated(cached_has_bits, 0x01000000U)) {
6008 _this->_internal_mutable_ignore_subsolvers()->InternalMergeFromWithArena(
6009 ::google::protobuf::MessageLite::internal_visibility(), arena,
6010 from._internal_ignore_subsolvers());
6012 if (CheckHasBitForRepeated(cached_has_bits, 0x02000000U)) {
6013 _this->_internal_mutable_subsolver_params()->InternalMergeFromWithArena(
6014 ::google::protobuf::MessageLite::internal_visibility(), arena,
6015 from._internal_subsolver_params());
6017 if (CheckHasBitForRepeated(cached_has_bits, 0x04000000U)) {
6018 _this->_internal_mutable_extra_subsolvers()->InternalMergeFromWithArena(
6019 ::google::protobuf::MessageLite::internal_visibility(), arena,
6020 from._internal_extra_subsolvers());
6022 if (CheckHasBitForRepeated(cached_has_bits, 0x08000000U)) {
6023 _this->_internal_mutable_filter_subsolvers()->InternalMergeFromWithArena(
6024 ::google::protobuf::MessageLite::internal_visibility(), arena,
6025 from._internal_filter_subsolvers());
6027 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6028 _this->_internal_set_default_restart_algorithms(from._internal_default_restart_algorithms());
6030 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6031 _this->_internal_set_name(from._internal_name());
6033 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6034 _this->_internal_set_log_prefix(from._internal_log_prefix());
6036 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6037 _this->_impl_.random_branches_ratio_ = from._impl_.random_branches_ratio_;
6040 cached_has_bits = from._impl_._has_bits_[1];
6041 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6042 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6043 _this->_impl_.max_sat_assumption_order_ = from._impl_.max_sat_assumption_order_;
6045 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6046 _this->_impl_.minimize_reduction_during_pb_resolution_ = from._impl_.minimize_reduction_during_pb_resolution_;
6048 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6049 _this->_impl_.max_sat_reverse_assumption_order_ = from._impl_.max_sat_reverse_assumption_order_;
6051 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6052 _this->_impl_.use_blocking_restart_ = from._impl_.use_blocking_restart_;
6054 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6055 _this->_impl_.use_erwa_heuristic_ = from._impl_.use_erwa_heuristic_;
6057 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6058 _this->_impl_.clause_cleanup_ordering_ = from._impl_.clause_cleanup_ordering_;
6060 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6061 _this->_impl_.num_conflicts_before_strategy_changes_ = from._impl_.num_conflicts_before_strategy_changes_;
6063 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6064 _this->_impl_.strategy_change_increase_ratio_ = from._impl_.strategy_change_increase_ratio_;
6067 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
6068 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6069 _this->_impl_.initial_variables_activity_ = from._impl_.initial_variables_activity_;
6071 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6072 _this->_impl_.also_bump_variables_in_conflict_reasons_ = from._impl_.also_bump_variables_in_conflict_reasons_;
6074 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6075 _this->_impl_.use_overload_checker_in_cumulative_ = from._impl_.use_overload_checker_in_cumulative_;
6077 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6078 _this->_impl_.use_timetable_edge_finding_in_cumulative_ = from._impl_.use_timetable_edge_finding_in_cumulative_;
6080 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6081 _this->_impl_.optimize_with_core_ = from._impl_.optimize_with_core_;
6083 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6084 _this->_impl_.search_branching_ = from._impl_.search_branching_;
6086 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6087 _this->_impl_.optimize_with_max_hs_ = from._impl_.optimize_with_max_hs_;
6089 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
6090 _this->_impl_.enumerate_all_solutions_ = from._impl_.enumerate_all_solutions_;
6093 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
6094 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
6095 _this->_impl_.only_add_cuts_at_level_zero_ = from._impl_.only_add_cuts_at_level_zero_;
6097 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
6098 _this->_impl_.stop_after_first_solution_ = from._impl_.stop_after_first_solution_;
6100 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
6101 _this->_impl_.num_search_workers_ = from._impl_.num_search_workers_;
6103 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
6104 _this->_impl_.search_random_variable_pool_size_ = from._impl_.search_random_variable_pool_size_;
6106 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
6107 _this->_impl_.use_lns_only_ = from._impl_.use_lns_only_;
6109 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
6110 _this->_impl_.randomize_search_ = from._impl_.randomize_search_;
6112 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
6113 _this->_impl_.use_optional_variables_ = from._impl_.use_optional_variables_;
6115 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
6116 _this->_impl_.exploit_best_solution_ = from._impl_.exploit_best_solution_;
6119 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6120 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
6121 _this->_impl_.interleave_batch_size_ = from._impl_.interleave_batch_size_;
6123 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
6124 _this->_impl_.fill_tightened_domains_in_response_ = from._impl_.fill_tightened_domains_in_response_;
6126 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
6127 _this->_impl_.use_combined_no_overlap_ = from._impl_.use_combined_no_overlap_;
6129 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
6130 _this->_impl_.interleave_search_ = from._impl_.interleave_search_;
6132 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6133 _this->_impl_.diversify_lns_params_ = from._impl_.diversify_lns_params_;
6135 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6136 _this->_impl_.debug_max_num_presolve_operations_ = from._impl_.debug_max_num_presolve_operations_;
6138 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6139 _this->_impl_.relative_gap_limit_ = from._impl_.relative_gap_limit_;
6141 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6142 _this->_impl_.stop_after_presolve_ = from._impl_.stop_after_presolve_;
6145 cached_has_bits = from._impl_._has_bits_[2];
6146 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6147 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6148 _this->_impl_.exploit_relaxation_solution_ = from._impl_.exploit_relaxation_solution_;
6150 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6151 _this->_impl_.debug_postsolve_with_full_solver_ = from._impl_.debug_postsolve_with_full_solver_;
6153 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6154 _this->_impl_.repair_hint_ = from._impl_.repair_hint_;
6156 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6157 _this->_impl_.expand_alldiff_constraints_ = from._impl_.expand_alldiff_constraints_;
6159 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6160 _this->_impl_.keep_all_feasible_solutions_in_presolve_ = from._impl_.keep_all_feasible_solutions_in_presolve_;
6162 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6163 _this->_impl_.presolve_extract_integer_enforcement_ = from._impl_.presolve_extract_integer_enforcement_;
6165 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6166 _this->_impl_.polish_lp_solution_ = from._impl_.polish_lp_solution_;
6168 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6169 _this->_impl_.use_probing_search_ = from._impl_.use_probing_search_;
6172 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
6173 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6174 _this->_impl_.permute_variable_randomly_ = from._impl_.permute_variable_randomly_;
6176 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6177 _this->_impl_.permute_presolve_constraint_order_ = from._impl_.permute_presolve_constraint_order_;
6179 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6180 _this->_impl_.use_absl_random_ = from._impl_.use_absl_random_;
6182 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6183 _this->_impl_.disable_constraint_expansion_ = from._impl_.disable_constraint_expansion_;
6185 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6186 _this->_impl_.log_to_response_ = from._impl_.log_to_response_;
6188 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6189 _this->_impl_.optimize_with_lb_tree_search_ = from._impl_.optimize_with_lb_tree_search_;
6191 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6192 _this->_impl_.log_subsolver_statistics_ = from._impl_.log_subsolver_statistics_;
6194 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
6195 _this->_impl_.fix_variables_to_their_hinted_value_ = from._impl_.fix_variables_to_their_hinted_value_;
6198 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
6199 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
6200 _this->_impl_.fill_additional_solutions_in_response_ = from._impl_.fill_additional_solutions_in_response_;
6202 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
6203 _this->_impl_.debug_crash_on_bad_hint_ = from._impl_.debug_crash_on_bad_hint_;
6205 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
6206 _this->_impl_.add_objective_cut_ = from._impl_.add_objective_cut_;
6208 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
6209 _this->_impl_.num_workers_ = from._impl_.num_workers_;
6211 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
6212 _this->_impl_.use_timetabling_in_no_overlap_2d_ = from._impl_.use_timetabling_in_no_overlap_2d_;
6214 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
6215 _this->_impl_.use_energetic_reasoning_in_no_overlap_2d_ = from._impl_.use_energetic_reasoning_in_no_overlap_2d_;
6217 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
6218 _this->_impl_.use_hard_precedences_in_cumulative_ = from._impl_.use_hard_precedences_in_cumulative_;
6220 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
6221 _this->_impl_.detect_table_with_cost_ = from._impl_.detect_table_with_cost_;
6224 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6225 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
6226 _this->_impl_.exploit_all_precedences_ = from._impl_.exploit_all_precedences_;
6228 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
6229 _this->_impl_.only_solve_ip_ = from._impl_.only_solve_ip_;
6231 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
6232 _this->_impl_.encode_complex_linear_constraint_with_integer_ = from._impl_.encode_complex_linear_constraint_with_integer_;
6234 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
6235 _this->_impl_.mip_scale_large_domain_ = from._impl_.mip_scale_large_domain_;
6237 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6238 _this->_impl_.use_objective_lb_search_ = from._impl_.use_objective_lb_search_;
6240 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6241 _this->_impl_.use_strong_propagation_in_disjunctive_ = from._impl_.use_strong_propagation_in_disjunctive_;
6243 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6244 _this->_impl_.use_shared_tree_search_ = from._impl_.use_shared_tree_search_;
6246 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6247 _this->_impl_.use_ls_only_ = from._impl_.use_ls_only_;
6250 cached_has_bits = from._impl_._has_bits_[3];
6251 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6252 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6253 _this->_impl_.shared_tree_split_strategy_ = from._impl_.shared_tree_split_strategy_;
6255 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6256 _this->_impl_.num_violation_ls_ = from._impl_.num_violation_ls_;
6258 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6259 _this->_impl_.stop_after_root_propagation_ = from._impl_.stop_after_root_propagation_;
6261 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6262 _this->_impl_.use_objective_shaving_search_ = from._impl_.use_objective_shaving_search_;
6264 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6265 _this->_impl_.push_all_tasks_toward_start_ = from._impl_.push_all_tasks_toward_start_;
6267 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6268 _this->_impl_.use_dynamic_precedence_in_disjunctive_ = from._impl_.use_dynamic_precedence_in_disjunctive_;
6270 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6271 _this->_impl_.use_dynamic_precedence_in_cumulative_ = from._impl_.use_dynamic_precedence_in_cumulative_;
6273 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6274 _this->_impl_.use_area_energetic_reasoning_in_no_overlap_2d_ = from._impl_.use_area_energetic_reasoning_in_no_overlap_2d_;
6277 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
6278 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6279 _this->_impl_.detect_linearized_product_ = from._impl_.detect_linearized_product_;
6281 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6282 _this->_impl_.mip_treat_high_magnitude_bounds_as_infinity_ = from._impl_.mip_treat_high_magnitude_bounds_as_infinity_;
6284 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6285 _this->_impl_.max_lin_max_size_for_expansion_ = from._impl_.max_lin_max_size_for_expansion_;
6287 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6288 _this->_impl_.save_lp_basis_in_lb_tree_search_ = from._impl_.save_lp_basis_in_lb_tree_search_;
6290 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6291 _this->_impl_.use_conservative_scale_overload_checker_ = from._impl_.use_conservative_scale_overload_checker_;
6293 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6294 _this->_impl_.encode_cumulative_as_reservoir_ = from._impl_.encode_cumulative_as_reservoir_;
6296 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6297 _this->_impl_.expand_reservoir_using_circuit_ = from._impl_.expand_reservoir_using_circuit_;
6299 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
6300 _this->_impl_.max_num_deterministic_batches_ = from._impl_.max_num_deterministic_batches_;
6303 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
6304 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
6305 _this->_impl_.num_full_subsolvers_ = from._impl_.num_full_subsolvers_;
6307 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
6308 _this->_impl_.inprocessing_minimization_use_all_orderings_ = from._impl_.inprocessing_minimization_use_all_orderings_;
6310 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
6311 _this->_impl_.use_try_edge_reasoning_in_no_overlap_2d_ = from._impl_.use_try_edge_reasoning_in_no_overlap_2d_;
6313 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
6314 _this->_impl_.use_symmetry_in_lp_ = from._impl_.use_symmetry_in_lp_;
6316 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
6317 _this->_impl_.keep_symmetry_in_presolve_ = from._impl_.keep_symmetry_in_presolve_;
6319 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
6320 _this->_impl_.routing_cut_subset_size_for_binary_relation_bound_ = from._impl_.routing_cut_subset_size_for_binary_relation_bound_;
6322 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
6323 _this->_impl_.debug_crash_if_presolve_breaks_hint_ = from._impl_.debug_crash_if_presolve_breaks_hint_;
6325 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
6326 _this->_impl_.polarity_exploit_ls_hints_ = from._impl_.polarity_exploit_ls_hints_;
6329 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6330 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
6331 _this->_impl_.use_all_different_for_circuit_ = from._impl_.use_all_different_for_circuit_;
6333 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
6334 _this->_impl_.filter_sat_postsolve_clauses_ = from._impl_.filter_sat_postsolve_clauses_;
6336 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
6337 _this->_impl_.routing_cut_subset_size_for_tight_binary_relation_bound_ = from._impl_.routing_cut_subset_size_for_tight_binary_relation_bound_;
6339 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
6340 _this->_impl_.maximum_regions_to_split_in_disconnected_no_overlap_2d_ = from._impl_.maximum_regions_to_split_in_disconnected_no_overlap_2d_;
6342 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6343 _this->_impl_.share_linear2_bounds_ = from._impl_.share_linear2_bounds_;
6345 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6346 _this->_impl_.use_chronological_backtracking_ = from._impl_.use_chronological_backtracking_;
6348 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6349 _this->_impl_.load_at_most_ones_in_sat_presolve_ = from._impl_.load_at_most_ones_in_sat_presolve_;
6351 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6352 _this->_impl_.use_new_integer_conflict_resolution_ = from._impl_.use_new_integer_conflict_resolution_;
6355 cached_has_bits = from._impl_._has_bits_[4];
6356 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6357 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6358 _this->_impl_.clause_cleanup_period_increment_ = from._impl_.clause_cleanup_period_increment_;
6360 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6361 _this->_impl_.debug_crash_if_lrat_check_fails_ = from._impl_.debug_crash_if_lrat_check_fails_;
6363 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6364 _this->_impl_.check_lrat_proof_ = from._impl_.check_lrat_proof_;
6366 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6367 _this->_impl_.output_lrat_proof_ = from._impl_.output_lrat_proof_;
6369 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6370 _this->_impl_.check_drat_proof_ = from._impl_.check_drat_proof_;
6372 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6373 _this->_impl_.clause_cleanup_lbd_tier1_ = from._impl_.clause_cleanup_lbd_tier1_;
6375 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6376 _this->_impl_.clause_cleanup_lbd_tier2_ = from._impl_.clause_cleanup_lbd_tier2_;
6378 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6379 _this->_impl_.output_drat_proof_ = from._impl_.output_drat_proof_;
6382 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
6383 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6384 _this->_impl_.check_merged_lrat_proof_ = from._impl_.check_merged_lrat_proof_;
6386 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6387 _this->_impl_.inprocessing_use_sat_sweeping_ = from._impl_.inprocessing_use_sat_sweeping_;
6389 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6390 _this->_impl_.max_memory_in_mb_ = from._impl_.max_memory_in_mb_;
6392 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6393 _this->_impl_.binary_minimization_algorithm_ = from._impl_.binary_minimization_algorithm_;
6395 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6396 _this->_impl_.pb_cleanup_increment_ = from._impl_.pb_cleanup_increment_;
6398 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6399 _this->_impl_.pb_cleanup_ratio_ = from._impl_.pb_cleanup_ratio_;
6401 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6402 _this->_impl_.core_minimization_level_ = from._impl_.core_minimization_level_;
6404 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
6405 _this->_impl_.max_sat_stratification_ = from._impl_.max_sat_stratification_;
6408 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
6409 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
6410 _this->_impl_.presolve_bve_threshold_ = from._impl_.presolve_bve_threshold_;
6412 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
6413 _this->_impl_.presolve_bve_clause_weight_ = from._impl_.presolve_bve_clause_weight_;
6415 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
6416 _this->_impl_.presolve_probing_deterministic_time_limit_ = from._impl_.presolve_probing_deterministic_time_limit_;
6418 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
6419 _this->_impl_.clause_cleanup_lbd_bound_ = from._impl_.clause_cleanup_lbd_bound_;
6421 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
6422 _this->_impl_.restart_running_window_size_ = from._impl_.restart_running_window_size_;
6424 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
6425 _this->_impl_.restart_dl_average_ratio_ = from._impl_.restart_dl_average_ratio_;
6427 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
6428 _this->_impl_.count_assumption_levels_in_lbd_ = from._impl_.count_assumption_levels_in_lbd_;
6430 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
6431 _this->_impl_.subsumption_during_conflict_analysis_ = from._impl_.subsumption_during_conflict_analysis_;
6434 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6435 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
6436 _this->_impl_.presolve_use_bva_ = from._impl_.presolve_use_bva_;
6438 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
6439 _this->_impl_.use_disjunctive_constraint_in_cumulative_ = from._impl_.use_disjunctive_constraint_in_cumulative_;
6441 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
6442 _this->_impl_.blocking_restart_window_size_ = from._impl_.blocking_restart_window_size_;
6444 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
6445 _this->_impl_.blocking_restart_multiplier_ = from._impl_.blocking_restart_multiplier_;
6447 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6448 _this->_impl_.max_deterministic_time_ = from._impl_.max_deterministic_time_;
6450 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6451 _this->_impl_.restart_lbd_average_ratio_ = from._impl_.restart_lbd_average_ratio_;
6453 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6454 _this->_impl_.presolve_bva_threshold_ = from._impl_.presolve_bva_threshold_;
6456 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6457 _this->_impl_.find_multiple_cores_ = from._impl_.find_multiple_cores_;
6460 cached_has_bits = from._impl_._has_bits_[5];
6461 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6462 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6463 _this->_impl_.cp_model_presolve_ = from._impl_.cp_model_presolve_;
6465 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6466 _this->_impl_.presolve_blocked_clause_ = from._impl_.presolve_blocked_clause_;
6468 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6469 _this->_impl_.cover_optimization_ = from._impl_.cover_optimization_;
6471 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6472 _this->_impl_.linearization_level_ = from._impl_.linearization_level_;
6474 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6475 _this->_impl_.max_num_cuts_ = from._impl_.max_num_cuts_;
6477 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6478 _this->_impl_.cp_model_use_sat_presolve_ = from._impl_.cp_model_use_sat_presolve_;
6480 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6481 _this->_impl_.exploit_integer_lp_solution_ = from._impl_.exploit_integer_lp_solution_;
6483 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6484 _this->_impl_.auto_detect_greater_than_at_least_one_of_ = from._impl_.auto_detect_greater_than_at_least_one_of_;
6487 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
6488 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6489 _this->_impl_.instantiate_all_variables_ = from._impl_.instantiate_all_variables_;
6491 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6492 _this->_impl_.binary_search_num_conflicts_ = from._impl_.binary_search_num_conflicts_;
6494 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6495 _this->_impl_.boolean_encoding_level_ = from._impl_.boolean_encoding_level_;
6497 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6498 _this->_impl_.cp_model_probing_level_ = from._impl_.cp_model_probing_level_;
6500 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6501 _this->_impl_.use_exact_lp_reason_ = from._impl_.use_exact_lp_reason_;
6503 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6504 _this->_impl_.add_lp_constraints_lazily_ = from._impl_.add_lp_constraints_lazily_;
6506 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6507 _this->_impl_.share_objective_bounds_ = from._impl_.share_objective_bounds_;
6509 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
6510 _this->_impl_.share_level_zero_bounds_ = from._impl_.share_level_zero_bounds_;
6513 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
6514 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
6515 _this->_impl_.max_integer_rounding_scaling_ = from._impl_.max_integer_rounding_scaling_;
6517 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
6518 _this->_impl_.min_orthogonality_for_lp_constraints_ = from._impl_.min_orthogonality_for_lp_constraints_;
6520 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
6521 _this->_impl_.exploit_all_lp_solution_ = from._impl_.exploit_all_lp_solution_;
6523 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
6524 _this->_impl_.add_cg_cuts_ = from._impl_.add_cg_cuts_;
6526 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
6527 _this->_impl_.add_mir_cuts_ = from._impl_.add_mir_cuts_;
6529 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
6530 _this->_impl_.use_rins_lns_ = from._impl_.use_rins_lns_;
6532 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
6533 _this->_impl_.max_consecutive_inactive_count_ = from._impl_.max_consecutive_inactive_count_;
6535 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
6536 _this->_impl_.pseudo_cost_reliability_threshold_ = from._impl_.pseudo_cost_reliability_threshold_;
6539 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6540 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
6541 _this->_impl_.mip_max_bound_ = from._impl_.mip_max_bound_;
6543 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
6544 _this->_impl_.new_constraints_batch_size_ = from._impl_.new_constraints_batch_size_;
6546 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
6547 _this->_impl_.mip_max_activity_exponent_ = from._impl_.mip_max_activity_exponent_;
6549 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
6550 _this->_impl_.mip_var_scaling_ = from._impl_.mip_var_scaling_;
6552 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6553 _this->_impl_.mip_wanted_precision_ = from._impl_.mip_wanted_precision_;
6555 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6556 _this->_impl_.mip_check_precision_ = from._impl_.mip_check_precision_;
6558 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6559 _this->_impl_.max_presolve_iterations_ = from._impl_.max_presolve_iterations_;
6561 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6562 _this->_impl_.exploit_objective_ = from._impl_.exploit_objective_;
6565 cached_has_bits = from._impl_._has_bits_[6];
6566 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6567 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6568 _this->_impl_.catch_sigint_signal_ = from._impl_.catch_sigint_signal_;
6570 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6571 _this->_impl_.use_implied_bounds_ = from._impl_.use_implied_bounds_;
6573 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6574 _this->_impl_.add_lin_max_cuts_ = from._impl_.add_lin_max_cuts_;
6576 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6577 _this->_impl_.merge_no_overlap_work_limit_ = from._impl_.merge_no_overlap_work_limit_;
6579 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6580 _this->_impl_.merge_at_most_one_work_limit_ = from._impl_.merge_at_most_one_work_limit_;
6582 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6583 _this->_impl_.presolve_substitution_level_ = from._impl_.presolve_substitution_level_;
6585 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6586 _this->_impl_.max_all_diff_cut_size_ = from._impl_.max_all_diff_cut_size_;
6588 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6589 _this->_impl_.hint_conflict_limit_ = from._impl_.hint_conflict_limit_;
6592 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
6593 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6594 _this->_impl_.max_cut_rounds_at_level_zero_ = from._impl_.max_cut_rounds_at_level_zero_;
6596 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6597 _this->_impl_.cut_max_active_count_value_ = from._impl_.cut_max_active_count_value_;
6599 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6600 _this->_impl_.cut_active_count_decay_ = from._impl_.cut_active_count_decay_;
6602 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6603 _this->_impl_.absolute_gap_limit_ = from._impl_.absolute_gap_limit_;
6605 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6606 _this->_impl_.cut_cleanup_target_ = from._impl_.cut_cleanup_target_;
6608 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6609 _this->_impl_.fp_rounding_ = from._impl_.fp_rounding_;
6611 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6612 _this->_impl_.use_sat_inprocessing_ = from._impl_.use_sat_inprocessing_;
6614 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
6615 _this->_impl_.use_feasibility_pump_ = from._impl_.use_feasibility_pump_;
6618 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
6619 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
6620 _this->_impl_.mip_automatically_scale_variables_ = from._impl_.mip_automatically_scale_variables_;
6622 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
6623 _this->_impl_.add_zero_half_cuts_ = from._impl_.add_zero_half_cuts_;
6625 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
6626 _this->_impl_.polarity_rephase_increment_ = from._impl_.polarity_rephase_increment_;
6628 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
6629 _this->_impl_.add_clique_cuts_ = from._impl_.add_clique_cuts_;
6631 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
6632 _this->_impl_.convert_intervals_ = from._impl_.convert_intervals_;
6634 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
6635 _this->_impl_.expand_reservoir_constraints_ = from._impl_.expand_reservoir_constraints_;
6637 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
6638 _this->_impl_.log_to_stdout_ = from._impl_.log_to_stdout_;
6640 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
6641 _this->_impl_.symmetry_level_ = from._impl_.symmetry_level_;
6644 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6645 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
6646 _this->_impl_.clause_cleanup_ratio_ = from._impl_.clause_cleanup_ratio_;
6648 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
6649 _this->_impl_.max_domain_size_when_encoding_eq_neq_constraints_ = from._impl_.max_domain_size_when_encoding_eq_neq_constraints_;
6651 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
6652 _this->_impl_.solution_pool_size_ = from._impl_.solution_pool_size_;
6654 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
6655 _this->_impl_.mip_max_valid_magnitude_ = from._impl_.mip_max_valid_magnitude_;
6657 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6658 _this->_impl_.presolve_inclusion_work_limit_ = from._impl_.presolve_inclusion_work_limit_;
6660 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6661 _this->_impl_.cut_level_ = from._impl_.cut_level_;
6663 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6664 _this->_impl_.mip_compute_true_objective_bound_ = from._impl_.mip_compute_true_objective_bound_;
6666 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6667 _this->_impl_.ignore_names_ = from._impl_.ignore_names_;
6670 cached_has_bits = from._impl_._has_bits_[7];
6671 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6672 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6673 _this->_impl_.share_binary_clauses_ = from._impl_.share_binary_clauses_;
6675 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6676 _this->_impl_.use_dual_scheduling_heuristics_ = from._impl_.use_dual_scheduling_heuristics_;
6678 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6679 _this->_impl_.shaving_deterministic_time_in_probing_search_ = from._impl_.shaving_deterministic_time_in_probing_search_;
6681 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6682 _this->_impl_.shaving_search_deterministic_time_ = from._impl_.shaving_search_deterministic_time_;
6684 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6685 _this->_impl_.propagation_loop_detection_factor_ = from._impl_.propagation_loop_detection_factor_;
6687 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6688 _this->_impl_.table_compression_level_ = from._impl_.table_compression_level_;
6690 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6691 _this->_impl_.root_lp_iterations_ = from._impl_.root_lp_iterations_;
6693 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6694 _this->_impl_.probing_deterministic_time_limit_ = from._impl_.probing_deterministic_time_limit_;
6697 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
6698 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6699 _this->_impl_.mip_drop_tolerance_ = from._impl_.mip_drop_tolerance_;
6701 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6702 _this->_impl_.max_size_to_create_precedence_literals_in_disjunctive_ = from._impl_.max_size_to_create_precedence_literals_in_disjunctive_;
6704 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6705 _this->_impl_.shared_tree_num_workers_ = from._impl_.shared_tree_num_workers_;
6707 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6708 _this->_impl_.new_linear_propagation_ = from._impl_.new_linear_propagation_;
6710 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6711 _this->_impl_.infer_all_diffs_ = from._impl_.infer_all_diffs_;
6713 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6714 _this->_impl_.find_big_linear_overlap_ = from._impl_.find_big_linear_overlap_;
6716 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6717 _this->_impl_.feasibility_jump_enable_restarts_ = from._impl_.feasibility_jump_enable_restarts_;
6719 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
6720 _this->_impl_.shared_tree_max_nodes_per_worker_ = from._impl_.shared_tree_max_nodes_per_worker_;
6723 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
6724 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
6725 _this->_impl_.feasibility_jump_decay_ = from._impl_.feasibility_jump_decay_;
6727 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
6728 _this->_impl_.feasibility_jump_var_randomization_probability_ = from._impl_.feasibility_jump_var_randomization_probability_;
6730 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
6731 _this->_impl_.feasibility_jump_var_perburbation_range_ratio_ = from._impl_.feasibility_jump_var_perburbation_range_ratio_;
6733 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
6734 _this->_impl_.violation_ls_perturbation_period_ = from._impl_.violation_ls_perturbation_period_;
6736 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
6737 _this->_impl_.linear_split_size_ = from._impl_.linear_split_size_;
6739 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
6740 _this->_impl_.feasibility_jump_linearization_level_ = from._impl_.feasibility_jump_linearization_level_;
6742 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
6743 _this->_impl_.feasibility_jump_restart_factor_ = from._impl_.feasibility_jump_restart_factor_;
6745 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
6746 _this->_impl_.violation_ls_compound_move_probability_ = from._impl_.violation_ls_compound_move_probability_;
6749 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6750 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
6751 _this->_impl_.max_num_intervals_for_timetable_edge_finding_ = from._impl_.max_num_intervals_for_timetable_edge_finding_;
6753 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
6754 _this->_impl_.mip_presolve_level_ = from._impl_.mip_presolve_level_;
6756 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
6757 _this->_impl_.lp_primal_tolerance_ = from._impl_.lp_primal_tolerance_;
6759 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
6760 _this->_impl_.feasibility_jump_max_expanded_constraint_size_ = from._impl_.feasibility_jump_max_expanded_constraint_size_;
6762 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6763 _this->_impl_.use_lb_relax_lns_ = from._impl_.use_lb_relax_lns_;
6765 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6766 _this->_impl_.use_feasibility_jump_ = from._impl_.use_feasibility_jump_;
6768 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6769 _this->_impl_.use_extended_probing_ = from._impl_.use_extended_probing_;
6771 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6772 _this->_impl_.add_rlt_cuts_ = from._impl_.add_rlt_cuts_;
6775 cached_has_bits = from._impl_._has_bits_[8];
6776 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6777 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6778 _this->_impl_.lp_dual_tolerance_ = from._impl_.lp_dual_tolerance_;
6780 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6781 _this->_impl_.at_most_one_max_expansion_size_ = from._impl_.at_most_one_max_expansion_size_;
6783 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6784 _this->_impl_.probing_num_combinations_limit_ = from._impl_.probing_num_combinations_limit_;
6786 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6787 _this->_impl_.inprocessing_dtime_ratio_ = from._impl_.inprocessing_dtime_ratio_;
6789 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6790 _this->_impl_.inprocessing_probing_dtime_ = from._impl_.inprocessing_probing_dtime_;
6792 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6793 _this->_impl_.inprocessing_minimization_dtime_ = from._impl_.inprocessing_minimization_dtime_;
6795 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6796 _this->_impl_.max_pairs_pairwise_reasoning_in_no_overlap_2d_ = from._impl_.max_pairs_pairwise_reasoning_in_no_overlap_2d_;
6798 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6799 _this->_impl_.shared_tree_worker_min_restarts_per_subtree_ = from._impl_.shared_tree_worker_min_restarts_per_subtree_;
6802 if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
6803 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6804 _this->_impl_.shared_tree_open_leaves_per_worker_ = from._impl_.shared_tree_open_leaves_per_worker_;
6806 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6807 _this->_impl_.variables_shaving_level_ = from._impl_.variables_shaving_level_;
6809 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6810 _this->_impl_.use_lns_ = from._impl_.use_lns_;
6812 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6813 _this->_impl_.share_glue_clauses_ = from._impl_.share_glue_clauses_;
6815 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6816 _this->_impl_.shared_tree_worker_enable_trail_sharing_ = from._impl_.shared_tree_worker_enable_trail_sharing_;
6818 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6819 _this->_impl_.inprocessing_minimization_use_conflict_analysis_ = from._impl_.inprocessing_minimization_use_conflict_analysis_;
6821 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6822 _this->_impl_.shaving_search_threshold_ = from._impl_.shaving_search_threshold_;
6824 if (CheckHasBit(cached_has_bits, 0x00008000U)) {
6825 _this->_impl_.feasibility_jump_batch_dtime_ = from._impl_.feasibility_jump_batch_dtime_;
6828 if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
6829 if (CheckHasBit(cached_has_bits, 0x00010000U)) {
6830 _this->_impl_.lb_relax_num_workers_threshold_ = from._impl_.lb_relax_num_workers_threshold_;
6832 if (CheckHasBit(cached_has_bits, 0x00020000U)) {
6833 _this->_impl_.shared_tree_balance_tolerance_ = from._impl_.shared_tree_balance_tolerance_;
6835 if (CheckHasBit(cached_has_bits, 0x00040000U)) {
6836 _this->_impl_.symmetry_detection_deterministic_time_limit_ = from._impl_.symmetry_detection_deterministic_time_limit_;
6838 if (CheckHasBit(cached_has_bits, 0x00080000U)) {
6839 _this->_impl_.lns_initial_difficulty_ = from._impl_.lns_initial_difficulty_;
6841 if (CheckHasBit(cached_has_bits, 0x00100000U)) {
6842 _this->_impl_.lns_initial_deterministic_limit_ = from._impl_.lns_initial_deterministic_limit_;
6844 if (CheckHasBit(cached_has_bits, 0x00200000U)) {
6845 _this->_impl_.minimize_shared_clauses_ = from._impl_.minimize_shared_clauses_;
6847 if (CheckHasBit(cached_has_bits, 0x00400000U)) {
6848 _this->_impl_.shared_tree_worker_enable_phase_sharing_ = from._impl_.shared_tree_worker_enable_phase_sharing_;
6850 if (CheckHasBit(cached_has_bits, 0x00800000U)) {
6851 _this->_impl_.remove_fixed_variables_early_ = from._impl_.remove_fixed_variables_early_;
6854 if (BatchCheckHasBit(cached_has_bits, 0xff000000U)) {
6855 if (CheckHasBit(cached_has_bits, 0x01000000U)) {
6856 _this->_impl_.use_linear3_for_no_overlap_2d_precedences_ = from._impl_.use_linear3_for_no_overlap_2d_precedences_;
6858 if (CheckHasBit(cached_has_bits, 0x02000000U)) {
6859 _this->_impl_.routing_cut_subset_size_for_exact_binary_relation_bound_ = from._impl_.routing_cut_subset_size_for_exact_binary_relation_bound_;
6861 if (CheckHasBit(cached_has_bits, 0x04000000U)) {
6862 _this->_impl_.routing_cut_dp_effort_ = from._impl_.routing_cut_dp_effort_;
6864 if (CheckHasBit(cached_has_bits, 0x08000000U)) {
6865 _this->_impl_.routing_cut_max_infeasible_path_length_ = from._impl_.routing_cut_max_infeasible_path_length_;
6867 if (CheckHasBit(cached_has_bits, 0x10000000U)) {
6868 _this->_impl_.routing_cut_subset_size_for_shortest_paths_bound_ = from._impl_.routing_cut_subset_size_for_shortest_paths_bound_;
6870 if (CheckHasBit(cached_has_bits, 0x20000000U)) {
6871 _this->_impl_.max_alldiff_domain_size_ = from._impl_.max_alldiff_domain_size_;
6873 if (CheckHasBit(cached_has_bits, 0x40000000U)) {
6874 _this->_impl_.no_overlap_2d_boolean_relations_limit_ = from._impl_.no_overlap_2d_boolean_relations_limit_;
6876 if (CheckHasBit(cached_has_bits, 0x80000000U)) {
6877 _this->_impl_.share_glue_clauses_dtime_ = from._impl_.share_glue_clauses_dtime_;
6880 cached_has_bits = from._impl_._has_bits_[9];
6881 if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
6882 if (CheckHasBit(cached_has_bits, 0x00000001U)) {
6883 _this->_impl_.alternative_pool_size_ = from._impl_.alternative_pool_size_;
6885 if (CheckHasBit(cached_has_bits, 0x00000002U)) {
6886 _this->_impl_.transitive_precedences_work_limit_ = from._impl_.transitive_precedences_work_limit_;
6888 if (CheckHasBit(cached_has_bits, 0x00000004U)) {
6889 _this->_impl_.shared_tree_split_min_dtime_ = from._impl_.shared_tree_split_min_dtime_;
6891 if (CheckHasBit(cached_has_bits, 0x00000008U)) {
6892 _this->_impl_.solution_pool_diversity_limit_ = from._impl_.solution_pool_diversity_limit_;
6894 if (CheckHasBit(cached_has_bits, 0x00000010U)) {
6895 _this->_impl_.max_backjump_levels_ = from._impl_.max_backjump_levels_;
6897 if (CheckHasBit(cached_has_bits, 0x00000020U)) {
6898 _this->_impl_.chronological_backtrack_min_conflicts_ = from._impl_.chronological_backtrack_min_conflicts_;
6900 if (CheckHasBit(cached_has_bits, 0x00000040U)) {
6901 _this->_impl_.max_domain_size_for_linear2_expansion_ = from._impl_.max_domain_size_for_linear2_expansion_;
6903 if (CheckHasBit(cached_has_bits, 0x00000080U)) {
6904 _this->_impl_.find_clauses_that_are_exactly_one_ = from._impl_.find_clauses_that_are_exactly_one_;
6907 if (BatchCheckHasBit(cached_has_bits, 0x00007f00U)) {
6908 if (CheckHasBit(cached_has_bits, 0x00000100U)) {
6909 _this->_impl_.create_1uip_boolean_during_icr_ = from._impl_.create_1uip_boolean_during_icr_;
6911 if (CheckHasBit(cached_has_bits, 0x00000200U)) {
6912 _this->_impl_.inprocessing_use_congruence_closure_ = from._impl_.inprocessing_use_congruence_closure_;
6914 if (CheckHasBit(cached_has_bits, 0x00000400U)) {
6915 _this->_impl_.extra_subsumption_during_conflict_analysis_ = from._impl_.extra_subsumption_during_conflict_analysis_;
6917 if (CheckHasBit(cached_has_bits, 0x00000800U)) {
6918 _this->_impl_.eagerly_subsume_last_n_conflicts_ = from._impl_.eagerly_subsume_last_n_conflicts_;
6920 if (CheckHasBit(cached_has_bits, 0x00001000U)) {
6921 _this->_impl_.max_drat_time_in_seconds_ = from._impl_.max_drat_time_in_seconds_;
6923 if (CheckHasBit(cached_has_bits, 0x00002000U)) {
6924 _this->_impl_.decision_subsumption_during_conflict_analysis_ = from._impl_.decision_subsumption_during_conflict_analysis_;
6926 if (CheckHasBit(cached_has_bits, 0x00004000U)) {
6927 _this->_impl_.subsume_during_vivification_ = from._impl_.subsume_during_vivification_;
6930 _this->_impl_._has_bits_.Or(from._impl_._has_bits_);
6931 _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
6932 from._internal_metadata_);
6937 if (&from ==
this)
return;
6943void SatParameters::InternalSwap(
SatParameters* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
6945 auto* arena = GetArena();
6946 ABSL_DCHECK_EQ(arena, other->GetArena());
6947 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6948 swap(
_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
6949 swap(
_impl_._has_bits_[1], other->_impl_._has_bits_[1]);
6950 swap(
_impl_._has_bits_[2], other->_impl_._has_bits_[2]);
6951 swap(
_impl_._has_bits_[3], other->_impl_._has_bits_[3]);
6952 swap(
_impl_._has_bits_[4], other->_impl_._has_bits_[4]);
6953 swap(
_impl_._has_bits_[5], other->_impl_._has_bits_[5]);
6954 swap(
_impl_._has_bits_[6], other->_impl_._has_bits_[6]);
6955 swap(
_impl_._has_bits_[7], other->_impl_._has_bits_[7]);
6956 swap(
_impl_._has_bits_[8], other->_impl_._has_bits_[8]);
6957 swap(
_impl_._has_bits_[9], other->_impl_._has_bits_[9]);
6958 ::google::protobuf::internal::memswap<
6962 reinterpret_cast<char*
>(&
_impl_.preferred_variable_order_),
6963 reinterpret_cast<char*
>(&other->_impl_.preferred_variable_order_));
6964 _impl_.restart_algorithms_.InternalSwap(&other->_impl_.restart_algorithms_);
6965 _impl_.subsolvers_.InternalSwap(&other->_impl_.subsolvers_);
6966 _impl_.ignore_subsolvers_.InternalSwap(&other->_impl_.ignore_subsolvers_);
6967 _impl_.subsolver_params_.InternalSwap(&other->_impl_.subsolver_params_);
6968 _impl_.extra_subsolvers_.InternalSwap(&other->_impl_.extra_subsolvers_);
6969 _impl_.filter_subsolvers_.InternalSwap(&other->_impl_.filter_subsolvers_);
6970 ::_pbi::ArenaStringPtr::InternalSwap(&
_impl_.default_restart_algorithms_, &other->_impl_.default_restart_algorithms_, arena);
6971 ::_pbi::ArenaStringPtr::InternalSwap(&
_impl_.name_, &other->_impl_.name_, arena);
6972 ::_pbi::ArenaStringPtr::InternalSwap(&
_impl_.log_prefix_, &other->_impl_.log_prefix_, arena);
6973 ::google::protobuf::internal::memswap<
6977 reinterpret_cast<char*
>(&
_impl_.random_branches_ratio_),
6978 reinterpret_cast<char*
>(&other->_impl_.random_branches_ratio_));
6982 return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
6992PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type
6995 ::std::false_type{});
6996#include "google/protobuf/port_undef.inc"
static PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 ::std::false_type _static_init2_
static const ::_pb::Message *PROTOBUF_NONNULL const file_default_instances[]
decltype(::std::declval< SatParameters >()._impl_._has_bits_) HasBits
static constexpr ::int32_t kHasBitsOffset
friend class ::google::protobuf::MessageLite
friend void swap(SatParameters &a, SatParameters &b)
static constexpr auto InternalGenerateClassData_()
~SatParameters() PROTOBUF_FINAL
::size_t ByteSizeLong() const final
void CopyFrom(const SatParameters &from)
::uint8_t *PROTOBUF_NONNULL _InternalSerialize(::uint8_t *PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream *PROTOBUF_NONNULL stream) const final
ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL
::google::protobuf::Metadata GetMetadata() const
const ::google::protobuf::UnknownFieldSet & unknown_fields() const ABSL_ATTRIBUTE_LIFETIME_BOUND
void MergeFrom(const SatParameters &from)
friend class ::google::protobuf::Arena
static constexpr ::_pbi::MigrationSchema *PROTOBUF_NULLABLE schemas
SatParameters_MaxSatStratificationAlgorithm
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_FPRoundingMethod_descriptor()
PROTOBUF_CONSTINIT const uint32_t SatParameters_SearchBranching_internal_data_[]
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_SharedTreeSplitStrategy_descriptor()
PROTOBUF_CONSTINIT const uint32_t SatParameters_ClauseOrdering_internal_data_[]
SatParameters_RestartAlgorithm
SatParameters_VariableOrder
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_MaxSatStratificationAlgorithm_descriptor()
PROTOBUF_CONSTINIT const uint32_t SatParameters_BinaryMinizationAlgorithm_internal_data_[]
SatParameters_BinaryMinizationAlgorithm
PROTOBUF_CONSTINIT const uint32_t SatParameters_MaxSatAssumptionOrder_internal_data_[]
PROTOBUF_CONSTINIT const uint32_t SatParameters_VariableOrder_internal_data_[]
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_RestartAlgorithm_descriptor()
SatParameters_MaxSatAssumptionOrder
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const::google::protobuf::internal::ClassDataFull SatParameters_class_data_
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SatParametersDefaultTypeInternal _SatParameters_default_instance_
PROTOBUF_CONSTINIT const uint32_t SatParameters_FPRoundingMethod_internal_data_[]
SatParameters_FPRoundingMethod
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_VariableOrder_descriptor()
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_ClauseOrdering_descriptor()
SatParameters_SharedTreeSplitStrategy
SatParameters_ClauseOrdering
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_BinaryMinizationAlgorithm_descriptor()
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_SearchBranching_descriptor()
SatParameters_ConflictMinimizationAlgorithm
PROTOBUF_CONSTINIT const uint32_t SatParameters_SharedTreeSplitStrategy_internal_data_[]
PROTOBUF_CONSTINIT const uint32_t SatParameters_RestartAlgorithm_internal_data_[]
PROTOBUF_CONSTINIT const uint32_t SatParameters_Polarity_internal_data_[]
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_MaxSatAssumptionOrder_descriptor()
PROTOBUF_CONSTINIT const uint32_t SatParameters_MaxSatStratificationAlgorithm_internal_data_[]
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_Polarity_descriptor()
SatParameters_SearchBranching
PROTOBUF_CONSTINIT const uint32_t SatParameters_ConflictMinimizationAlgorithm_internal_data_[]
const ::google::protobuf::EnumDescriptor *PROTOBUF_NONNULL SatParameters_ConflictMinimizationAlgorithm_descriptor()
const ::uint32_t TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold)
PROTOBUF_CONSTINITconst ::_pbi::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto
::absl::once_flag descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto_once
static constexprconst ::_pb::ServiceDescriptor *PROTOBUF_NONNULL *PROTOBUF_NULLABLE file_level_service_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto
static const ::_pb::EnumDescriptor *PROTOBUF_NONNULL file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[11]
~SatParametersDefaultTypeInternal()
PROTOBUF_CONSTEXPR SatParametersDefaultTypeInternal()
1.15.0