sat_parameters.pb.cc

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ortools/sat/sat_parameters.proto
 
#include "ortools/sat/sat_parameters.pb.h"
 
#include <algorithm>
 
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
 
PROTOBUF_PRAGMA_INIT_SEG
namespace operations_research {
namespace sat {
constexpr SatParameters::SatParameters(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : restart_algorithms_()
  , default_restart_algorithms_(nullptr)
  , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , log_prefix_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , preferred_variable_order_(0)
 
  , clause_cleanup_target_(0)
  , random_branches_ratio_(0)
  , random_polarity_ratio_(0)
  , max_sat_assumption_order_(0)
 
  , clause_cleanup_protection_(0)
 
  , clause_cleanup_ordering_(0)
 
  , num_conflicts_before_strategy_changes_(0)
  , strategy_change_increase_ratio_(0)
  , initial_variables_activity_(0)
  , search_branching_(0)
 
  , use_erwa_heuristic_(false)
  , also_bump_variables_in_conflict_reasons_(false)
  , use_blocking_restart_(false)
  , permute_variable_randomly_(false)
  , num_search_workers_(0)
  , max_sat_reverse_assumption_order_(false)
  , use_overload_checker_in_cumulative_constraint_(false)
  , use_timetable_edge_finding_in_cumulative_constraint_(false)
  , use_cumulative_in_no_overlap_2d_(false)
  , search_randomization_tolerance_(int64_t{0})
  , use_pb_resolution_(false)
  , minimize_reduction_during_pb_resolution_(false)
  , use_sat_inprocessing_(false)
  , expand_alldiff_constraints_(false)
  , diversify_lns_params_(false)
  , randomize_search_(false)
  , use_branching_in_lp_(false)
  , use_combined_no_overlap_(false)
  , interleave_search_(false)
  , reduce_memory_usage_in_interleave_mode_(false)
  , use_lns_only_(false)
  , use_relaxation_lns_(false)
  , optimize_with_lb_tree_search_(false)
  , optimize_with_max_hs_(false)
  , enumerate_all_solutions_(false)
  , keep_all_feasible_solutions_in_presolve_(false)
  , exploit_best_solution_(false)
  , exploit_relaxation_solution_(false)
  , use_probing_search_(false)
  , optimize_with_core_(false)
  , fill_tightened_domains_in_response_(false)
  , fill_additional_solutions_in_response_(false)
  , stop_after_first_solution_(false)
  , stop_after_presolve_(false)
  , probing_period_at_root_(int64_t{0})
  , permute_presolve_constraint_order_(false)
  , use_absl_random_(false)
  , log_search_progress_(false)
  , log_to_response_(false)
  , debug_max_num_presolve_operations_(0)
  , relative_gap_limit_(0)
  , only_add_cuts_at_level_zero_(false)
  , add_objective_cut_(false)
  , repair_hint_(false)
  , fix_variables_to_their_hinted_value_(false)
  , polish_lp_solution_(false)
  , disable_constraint_expansion_(false)
  , presolve_extract_integer_enforcement_(false)
  , debug_postsolve_with_full_solver_(false)
  , debug_crash_on_bad_hint_(false)
  , cut_level_(1)
  , initial_polarity_(1)
 
  , minimization_algorithm_(2)
 
  , variable_activity_decay_(0.8)
  , max_variable_activity_value_(1e+100)
  , clause_activity_decay_(0.999)
  , clause_cleanup_period_(10000)
  , glucose_decay_increment_period_(5000)
  , max_clause_activity_value_(1e+20)
  , glucose_max_decay_(0.95)
  , glucose_decay_increment_(0.01)
  , restart_period_(50)
  , random_seed_(1)
  , max_time_in_seconds_(std::numeric_limits<double>::infinity())
  , max_number_of_conflicts_(int64_t{9223372036854775807})
  , max_memory_in_mb_(int64_t{10000})
  , binary_minimization_algorithm_(1)
 
  , pb_cleanup_increment_(200)
  , pb_cleanup_ratio_(0.5)
  , max_sat_stratification_(1)
 
  , presolve_bve_threshold_(500)
  , presolve_probing_deterministic_time_limit_(30)
  , presolve_bve_clause_weight_(3)
  , clause_cleanup_lbd_bound_(5)
  , restart_dl_average_ratio_(1)
  , restart_running_window_size_(50)
  , blocking_restart_window_size_(5000)
  , blocking_restart_multiplier_(1.4)
  , max_deterministic_time_(std::numeric_limits<double>::infinity())
  , cp_model_presolve_(true)
  , cp_model_use_sat_presolve_(true)
  , use_optimization_hints_(true)
  , minimize_core_(true)
  , presolve_bva_threshold_(1)
  , restart_lbd_average_ratio_(1)
  , use_phase_saving_(true)
  , subsumption_during_conflict_analysis_(true)
  , treat_binary_clauses_separately_(true)
  , log_subsolver_statistics_(true)
  , find_multiple_cores_(true)
  , cover_optimization_(true)
  , use_precedences_in_disjunctive_constraint_(true)
  , use_disjunctive_constraint_in_cumulative_constraint_(true)
  , linearization_level_(1)
  , max_num_cuts_(10000)
  , minimize_with_propagation_restart_period_(10)
  , minimize_with_propagation_num_decisions_(1000)
  , log_to_stdout_(true)
  , count_assumption_levels_in_lbd_(true)
  , presolve_blocked_clause_(true)
  , presolve_use_bva_(true)
  , binary_search_num_conflicts_(-1)
  , boolean_encoding_level_(1)
  , cp_model_probing_level_(2)
  , exploit_objective_(true)
  , instantiate_all_variables_(true)
  , auto_detect_greater_than_at_least_one_of_(true)
  , share_objective_bounds_(true)
  , add_lin_max_cuts_(true)
  , add_lp_constraints_lazily_(true)
  , exploit_integer_lp_solution_(true)
  , exploit_all_lp_solution_(true)
  , min_orthogonality_for_lp_constraints_(0.05)
  , max_integer_rounding_scaling_(600)
  , max_consecutive_inactive_count_(100)
  , pseudo_cost_reliability_threshold_(int64_t{100})
  , mip_max_bound_(10000000)
  , new_constraints_batch_size_(50)
  , mip_max_activity_exponent_(53)
  , mip_var_scaling_(1)
  , mip_wanted_precision_(1e-06)
  , mip_check_precision_(0.0001)
  , share_level_zero_bounds_(true)
  , use_rins_lns_(true)
  , use_feasibility_pump_(true)
  , use_optional_variables_(true)
  , interleave_batch_size_(1)
  , max_presolve_iterations_(3)
  , use_exact_lp_reason_(true)
  , catch_sigint_signal_(true)
  , use_implied_bounds_(true)
  , convert_intervals_(true)
  , merge_no_overlap_work_limit_(1000000000000)
  , add_cg_cuts_(true)
  , add_mir_cuts_(true)
  , add_zero_half_cuts_(true)
  , add_clique_cuts_(true)
  , presolve_substitution_level_(1)
  , merge_at_most_one_work_limit_(100000000)
  , max_all_diff_cut_size_(7)
  , hint_conflict_limit_(10)
  , cut_max_active_count_value_(10000000000)
  , max_cut_rounds_at_level_zero_(1)
  , cut_cleanup_target_(1000)
  , cut_active_count_decay_(0.8)
  , absolute_gap_limit_(0.0001)
  , fp_rounding_(2)
 
  , polarity_rephase_increment_(1000)
  , mip_automatically_scale_variables_(true)
  , mip_compute_true_objective_bound_(true)
  , symmetry_level_(2)
  , clause_cleanup_ratio_(0.5)
  , max_domain_size_when_encoding_eq_neq_constraints_(16)
  , solution_pool_size_(3)
  , mip_max_valid_magnitude_(1e+30){}
struct SatParametersDefaultTypeInternal {
  constexpr SatParametersDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~SatParametersDefaultTypeInternal() {}
  union {
    SatParameters _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SatParametersDefaultTypeInternal _SatParameters_default_instance_;
}  // namespace sat
}  // namespace operations_research
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_ortools_2fsat_2fsat_5fparameters_2eproto[1];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[11];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto = nullptr;
 
const uint32_t TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  ~0u,  // no _inlined_string_donated_
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, name_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, preferred_variable_order_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, initial_polarity_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_phase_saving_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, polarity_rephase_increment_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, random_polarity_ratio_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, random_branches_ratio_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_erwa_heuristic_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, initial_variables_activity_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, also_bump_variables_in_conflict_reasons_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, minimization_algorithm_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, binary_minimization_algorithm_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, subsumption_during_conflict_analysis_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, clause_cleanup_period_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, clause_cleanup_target_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, clause_cleanup_ratio_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, clause_cleanup_protection_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, clause_cleanup_lbd_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, clause_cleanup_ordering_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, pb_cleanup_increment_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, pb_cleanup_ratio_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, minimize_with_propagation_restart_period_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, minimize_with_propagation_num_decisions_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, variable_activity_decay_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_variable_activity_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, glucose_max_decay_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, glucose_decay_increment_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, glucose_decay_increment_period_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, clause_activity_decay_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_clause_activity_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, restart_algorithms_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, default_restart_algorithms_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, restart_period_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, restart_running_window_size_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, restart_dl_average_ratio_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, restart_lbd_average_ratio_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_blocking_restart_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, blocking_restart_window_size_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, blocking_restart_multiplier_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, num_conflicts_before_strategy_changes_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, strategy_change_increase_ratio_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_time_in_seconds_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_deterministic_time_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_number_of_conflicts_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_memory_in_mb_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, absolute_gap_limit_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, relative_gap_limit_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, treat_binary_clauses_separately_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, random_seed_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, permute_variable_randomly_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, permute_presolve_constraint_order_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_absl_random_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, log_search_progress_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, log_subsolver_statistics_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, log_prefix_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, log_to_stdout_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, log_to_response_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_pb_resolution_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, minimize_reduction_during_pb_resolution_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, count_assumption_levels_in_lbd_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, presolve_bve_threshold_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, presolve_bve_clause_weight_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, presolve_probing_deterministic_time_limit_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, presolve_blocked_clause_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, presolve_use_bva_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, presolve_bva_threshold_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_presolve_iterations_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, cp_model_presolve_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, cp_model_probing_level_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, cp_model_use_sat_presolve_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_sat_inprocessing_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, expand_alldiff_constraints_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, disable_constraint_expansion_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, merge_no_overlap_work_limit_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, merge_at_most_one_work_limit_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, presolve_substitution_level_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, presolve_extract_integer_enforcement_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, debug_postsolve_with_full_solver_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, debug_max_num_presolve_operations_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, debug_crash_on_bad_hint_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_optimization_hints_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, minimize_core_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, find_multiple_cores_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, cover_optimization_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_sat_assumption_order_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_sat_reverse_assumption_order_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_sat_stratification_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_precedences_in_disjunctive_constraint_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_overload_checker_in_cumulative_constraint_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_timetable_edge_finding_in_cumulative_constraint_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_disjunctive_constraint_in_cumulative_constraint_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_cumulative_in_no_overlap_2d_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, linearization_level_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, boolean_encoding_level_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_domain_size_when_encoding_eq_neq_constraints_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_num_cuts_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, cut_level_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, only_add_cuts_at_level_zero_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, add_objective_cut_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, add_cg_cuts_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, add_mir_cuts_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, add_zero_half_cuts_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, add_clique_cuts_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_all_diff_cut_size_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, add_lin_max_cuts_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_integer_rounding_scaling_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, add_lp_constraints_lazily_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, min_orthogonality_for_lp_constraints_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_cut_rounds_at_level_zero_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, max_consecutive_inactive_count_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, cut_max_active_count_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, cut_active_count_decay_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, cut_cleanup_target_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, new_constraints_batch_size_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, search_branching_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, hint_conflict_limit_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, repair_hint_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, fix_variables_to_their_hinted_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, exploit_integer_lp_solution_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, exploit_all_lp_solution_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, exploit_best_solution_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, exploit_relaxation_solution_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, exploit_objective_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, probing_period_at_root_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_probing_search_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, pseudo_cost_reliability_threshold_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, optimize_with_core_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, optimize_with_lb_tree_search_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, binary_search_num_conflicts_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, optimize_with_max_hs_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, enumerate_all_solutions_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, keep_all_feasible_solutions_in_presolve_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, fill_tightened_domains_in_response_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, fill_additional_solutions_in_response_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, instantiate_all_variables_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, auto_detect_greater_than_at_least_one_of_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, stop_after_first_solution_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, stop_after_presolve_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, num_search_workers_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, interleave_search_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, interleave_batch_size_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, reduce_memory_usage_in_interleave_mode_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, share_objective_bounds_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, share_level_zero_bounds_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_lns_only_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, solution_pool_size_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_rins_lns_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_feasibility_pump_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, fp_rounding_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_relaxation_lns_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, diversify_lns_params_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, randomize_search_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, search_randomization_tolerance_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_optional_variables_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_exact_lp_reason_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_branching_in_lp_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_combined_no_overlap_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, catch_sigint_signal_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, use_implied_bounds_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, polish_lp_solution_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, convert_intervals_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, symmetry_level_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, mip_max_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, mip_var_scaling_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, mip_automatically_scale_variables_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, mip_wanted_precision_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, mip_max_activity_exponent_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, mip_check_precision_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, mip_compute_true_objective_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::sat::SatParameters, mip_max_valid_magnitude_),
  1,
  3,
  65,
  99,
  161,
  6,
  5,
  14,
  12,
  15,
  66,
  80,
  100,
  70,
  4,
  165,
  8,
  87,
  9,
  81,
  82,
  109,
  110,
  67,
  68,
  73,
  74,
  71,
  69,
  72,
  ~0u,
  0,
  75,
  89,
  88,
  98,
  16,
  90,
  91,
  10,
  11,
  77,
  92,
  78,
  79,
  159,
  54,
  101,
  76,
  17,
  49,
  50,
  51,
  102,
  2,
  111,
  52,
  24,
  25,
  112,
  84,
  86,
  85,
  113,
  114,
  97,
  141,
  93,
  117,
  94,
  26,
  27,
  60,
  146,
  152,
  151,
  61,
  62,
  53,
  63,
  95,
  96,
  103,
  104,
  7,
  19,
  83,
  105,
  20,
  21,
  106,
  22,
  107,
  116,
  166,
  108,
  64,
  55,
  56,
  147,
  148,
  149,
  150,
  153,
  122,
  127,
  123,
  126,
  156,
  128,
  155,
  158,
  157,
  131,
  13,
  154,
  57,
  58,
  124,
  125,
  40,
  41,
  118,
  48,
  42,
  129,
  43,
  36,
  115,
  37,
  38,
  39,
  44,
  45,
  119,
  120,
  46,
  47,
  18,
  32,
  140,
  33,
  121,
  136,
  34,
  167,
  137,
  138,
  160,
  35,
  28,
  29,
  23,
  139,
  142,
  30,
  31,
  143,
  144,
  59,
  145,
  164,
  130,
  133,
  162,
  134,
  132,
  135,
  163,
  168,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 176, -1, sizeof(::operations_research::sat::SatParameters)},
};
 
static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::sat::_SatParameters_default_instance_),
};
 
const char descriptor_table_protodef_ortools_2fsat_2fsat_5fparameters_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n ortools/sat/sat_parameters.proto\022\027oper"
  "ations_research.sat\"\353E\n\rSatParameters\022\017\n"
  "\004name\030\253\001 \001(\t:\000\022`\n\030preferred_variable_ord"
  "er\030\001 \001(\01624.operations_research.sat.SatPa"
  "rameters.VariableOrder:\010IN_ORDER\022Y\n\020init"
  "ial_polarity\030\002 \001(\0162/.operations_research"
  ".sat.SatParameters.Polarity:\016POLARITY_FA"
  "LSE\022\036\n\020use_phase_saving\030, \001(\010:\004true\022)\n\032p"
  "olarity_rephase_increment\030\250\001 \001(\005:\0041000\022 "
  "\n\025random_polarity_ratio\030- \001(\001:\0010\022 \n\025rand"
  "om_branches_ratio\030  \001(\001:\0010\022!\n\022use_erwa_h"
  "euristic\030K \001(\010:\005false\022%\n\032initial_variabl"
  "es_activity\030L \001(\001:\0010\0226\n\'also_bump_variab"
  "les_in_conflict_reasons\030M \001(\010:\005false\022o\n\026"
  "minimization_algorithm\030\004 \001(\0162D.operation"
  "s_research.sat.SatParameters.ConflictMin"
  "imizationAlgorithm:\tRECURSIVE\022\202\001\n\035binary"
  "_minimization_algorithm\030\" \001(\0162@.operatio"
  "ns_research.sat.SatParameters.BinaryMini"
  "zationAlgorithm:\031BINARY_MINIMIZATION_FIR"
  "ST\0222\n$subsumption_during_conflict_analys"
  "is\0308 \001(\010:\004true\022$\n\025clause_cleanup_period\030"
  "\013 \001(\005:\00510000\022 \n\025clause_cleanup_target\030\r "
  "\001(\005:\0010\022\"\n\024clause_cleanup_ratio\030\276\001 \001(\001:\0030"
  ".5\022k\n\031clause_cleanup_protection\030: \001(\01627."
  "operations_research.sat.SatParameters.Cl"
  "auseProtection:\017PROTECTION_NONE\022#\n\030claus"
  "e_cleanup_lbd_bound\030; \001(\005:\0015\022g\n\027clause_c"
  "leanup_ordering\030< \001(\01625.operations_resea"
  "rch.sat.SatParameters.ClauseOrdering:\017CL"
  "AUSE_ACTIVITY\022!\n\024pb_cleanup_increment\030. "
  "\001(\005:\003200\022\035\n\020pb_cleanup_ratio\030/ \001(\001:\0030.5\022"
  "4\n(minimize_with_propagation_restart_per"
  "iod\030` \001(\005:\00210\0225\n\'minimize_with_propagati"
  "on_num_decisions\030a \001(\005:\0041000\022$\n\027variable"
  "_activity_decay\030\017 \001(\001:\0030.8\022+\n\033max_variab"
  "le_activity_value\030\020 \001(\001:\0061e+100\022\037\n\021gluco"
  "se_max_decay\030\026 \001(\001:\0040.95\022%\n\027glucose_deca"
  "y_increment\030\027 \001(\001:\0040.01\022,\n\036glucose_decay"
  "_increment_period\030\030 \001(\005:\0045000\022$\n\025clause_"
  "activity_decay\030\021 \001(\001:\0050.999\022(\n\031max_claus"
  "e_activity_value\030\022 \001(\001:\0051e+20\022S\n\022restart"
  "_algorithms\030= \003(\01627.operations_research."
  "sat.SatParameters.RestartAlgorithm\022e\n\032de"
  "fault_restart_algorithms\030F \001(\t:ALUBY_RES"
  "TART,LBD_MOVING_AVERAGE_RESTART,DL_MOVIN"
  "G_AVERAGE_RESTART\022\032\n\016restart_period\030\036 \001("
  "\005:\00250\022\'\n\033restart_running_window_size\030> \001"
  "(\005:\00250\022#\n\030restart_dl_average_ratio\030\? \001(\001"
  ":\0011\022$\n\031restart_lbd_average_ratio\030G \001(\001:\001"
  "1\022#\n\024use_blocking_restart\030@ \001(\010:\005false\022*"
  "\n\034blocking_restart_window_size\030A \001(\005:\00450"
  "00\022(\n\033blocking_restart_multiplier\030B \001(\001:"
  "\0031.4\0220\n%num_conflicts_before_strategy_ch"
  "anges\030D \001(\005:\0010\022)\n\036strategy_change_increa"
  "se_ratio\030E \001(\001:\0010\022 \n\023max_time_in_seconds"
  "\030$ \001(\001:\003inf\022#\n\026max_deterministic_time\030C "
  "\001(\001:\003inf\0224\n\027max_number_of_conflicts\030% \001("
  "\003:\0239223372036854775807\022\037\n\020max_memory_in_"
  "mb\030( \001(\003:\00510000\022#\n\022absolute_gap_limit\030\237\001"
  " \001(\001:\0060.0001\022\036\n\022relative_gap_limit\030\240\001 \001("
  "\001:\0010\022-\n\037treat_binary_clauses_separately\030"
  "! \001(\010:\004true\022\026\n\013random_seed\030\037 \001(\005:\0011\022)\n\031p"
  "ermute_variable_randomly\030\262\001 \001(\010:\005false\0221"
  "\n!permute_presolve_constraint_order\030\263\001 \001"
  "(\010:\005false\022\037\n\017use_absl_random\030\264\001 \001(\010:\005fal"
  "se\022\"\n\023log_search_progress\030) \001(\010:\005false\022\'"
  "\n\030log_subsolver_statistics\030\275\001 \001(\010:\004true\022"
  "\025\n\nlog_prefix\030\271\001 \001(\t:\000\022\034\n\rlog_to_stdout\030"
  "\272\001 \001(\010:\004true\022\037\n\017log_to_response\030\273\001 \001(\010:\005"
  "false\022 \n\021use_pb_resolution\030+ \001(\010:\005false\022"
  "6\n\'minimize_reduction_during_pb_resoluti"
  "on\0300 \001(\010:\005false\022,\n\036count_assumption_leve"
  "ls_in_lbd\0301 \001(\010:\004true\022#\n\026presolve_bve_th"
  "reshold\0306 \001(\005:\003500\022%\n\032presolve_bve_claus"
  "e_weight\0307 \001(\005:\0013\0225\n)presolve_probing_de"
  "terministic_time_limit\0309 \001(\001:\00230\022%\n\027pres"
  "olve_blocked_clause\030X \001(\010:\004true\022\036\n\020preso"
  "lve_use_bva\030H \001(\010:\004true\022!\n\026presolve_bva_"
  "threshold\030I \001(\005:\0011\022#\n\027max_presolve_itera"
  "tions\030\212\001 \001(\005:\0013\022\037\n\021cp_model_presolve\030V \001"
  "(\010:\004true\022!\n\026cp_model_probing_level\030n \001(\005"
  ":\0012\022\'\n\031cp_model_use_sat_presolve\030] \001(\010:\004"
  "true\022$\n\024use_sat_inprocessing\030\243\001 \001(\010:\005fal"
  "se\022*\n\032expand_alldiff_constraints\030\252\001 \001(\010:"
  "\005false\022,\n\034disable_constraint_expansion\030\265"
  "\001 \001(\010:\005false\0223\n\033merge_no_overlap_work_li"
  "mit\030\221\001 \001(\001:\r1000000000000\0220\n\034merge_at_mo"
  "st_one_work_limit\030\222\001 \001(\001:\t100000000\022\'\n\033p"
  "resolve_substitution_level\030\223\001 \001(\005:\0011\0224\n$"
  "presolve_extract_integer_enforcement\030\256\001 "
  "\001(\010:\005false\0220\n debug_postsolve_with_full_"
  "solver\030\242\001 \001(\010:\005false\022-\n!debug_max_num_pr"
  "esolve_operations\030\227\001 \001(\005:\0010\022\'\n\027debug_cra"
  "sh_on_bad_hint\030\303\001 \001(\010:\005false\022$\n\026use_opti"
  "mization_hints\030# \001(\010:\004true\022\033\n\rminimize_c"
  "ore\0302 \001(\010:\004true\022!\n\023find_multiple_cores\030T"
  " \001(\010:\004true\022 \n\022cover_optimization\030Y \001(\010:\004"
  "true\022x\n\030max_sat_assumption_order\0303 \001(\0162<"
  ".operations_research.sat.SatParameters.M"
  "axSatAssumptionOrder:\030DEFAULT_ASSUMPTION"
  "_ORDER\022/\n max_sat_reverse_assumption_ord"
  "er\0304 \001(\010:\005false\022|\n\026max_sat_stratificatio"
  "n\0305 \001(\0162D.operations_research.sat.SatPar"
  "ameters.MaxSatStratificationAlgorithm:\026S"
  "TRATIFICATION_DESCENT\0227\n)use_precedences"
  "_in_disjunctive_constraint\030J \001(\010:\004true\022<"
  "\n-use_overload_checker_in_cumulative_con"
  "straint\030N \001(\010:\005false\022B\n3use_timetable_ed"
  "ge_finding_in_cumulative_constraint\030O \001("
  "\010:\005false\022A\n3use_disjunctive_constraint_i"
  "n_cumulative_constraint\030P \001(\010:\004true\022/\n\037u"
  "se_cumulative_in_no_overlap_2d\030\310\001 \001(\010:\005f"
  "alse\022\036\n\023linearization_level\030Z \001(\005:\0011\022!\n\026"
  "boolean_encoding_level\030k \001(\005:\0011\022=\n0max_d"
  "omain_size_when_encoding_eq_neq_constrai"
  "nts\030\277\001 \001(\005:\00216\022\033\n\014max_num_cuts\030[ \001(\005:\00510"
  "000\022\025\n\tcut_level\030\304\001 \001(\005:\0011\022*\n\033only_add_c"
  "uts_at_level_zero\030\\ \001(\010:\005false\022!\n\021add_ob"
  "jective_cut\030\305\001 \001(\010:\005false\022\031\n\013add_cg_cuts"
  "\030u \001(\010:\004true\022\032\n\014add_mir_cuts\030x \001(\010:\004true"
  "\022!\n\022add_zero_half_cuts\030\251\001 \001(\010:\004true\022\036\n\017a"
  "dd_clique_cuts\030\254\001 \001(\010:\004true\022!\n\025max_all_d"
  "iff_cut_size\030\224\001 \001(\005:\0017\022\037\n\020add_lin_max_cu"
  "ts\030\230\001 \001(\010:\004true\022)\n\034max_integer_rounding_"
  "scaling\030w \001(\005:\003600\022\'\n\031add_lp_constraints"
  "_lazily\030p \001(\010:\004true\0222\n$min_orthogonality"
  "_for_lp_constraints\030s \001(\001:\0040.05\022(\n\034max_c"
  "ut_rounds_at_level_zero\030\232\001 \001(\005:\0011\022+\n\036max"
  "_consecutive_inactive_count\030y \001(\005:\003100\0220"
  "\n\032cut_max_active_count_value\030\233\001 \001(\001:\013100"
  "00000000\022$\n\026cut_active_count_decay\030\234\001 \001("
  "\001:\0030.8\022!\n\022cut_cleanup_target\030\235\001 \001(\005:\004100"
  "0\022&\n\032new_constraints_batch_size\030z \001(\005:\0025"
  "0\022b\n\020search_branching\030R \001(\01626.operations"
  "_research.sat.SatParameters.SearchBranch"
  "ing:\020AUTOMATIC_SEARCH\022 \n\023hint_conflict_l"
  "imit\030\231\001 \001(\005:\00210\022\033\n\013repair_hint\030\247\001 \001(\010:\005f"
  "alse\0223\n#fix_variables_to_their_hinted_va"
  "lue\030\300\001 \001(\010:\005false\022)\n\033exploit_integer_lp_"
  "solution\030^ \001(\010:\004true\022%\n\027exploit_all_lp_s"
  "olution\030t \001(\010:\004true\022%\n\025exploit_best_solu"
  "tion\030\202\001 \001(\010:\005false\022+\n\033exploit_relaxation"
  "_solution\030\241\001 \001(\010:\005false\022 \n\021exploit_objec"
  "tive\030\203\001 \001(\010:\004true\022\"\n\026probing_period_at_r"
  "oot\030\216\001 \001(\003:\0010\022\"\n\022use_probing_search\030\260\001 \001"
  "(\010:\005false\022.\n!pseudo_cost_reliability_thr"
  "eshold\030{ \001(\003:\003100\022!\n\022optimize_with_core\030"
  "S \001(\010:\005false\022,\n\034optimize_with_lb_tree_se"
  "arch\030\274\001 \001(\010:\005false\022\'\n\033binary_search_num_"
  "conflicts\030c \001(\005:\002-1\022#\n\024optimize_with_max"
  "_hs\030U \001(\010:\005false\022&\n\027enumerate_all_soluti"
  "ons\030W \001(\010:\005false\0227\n\'keep_all_feasible_so"
  "lutions_in_presolve\030\255\001 \001(\010:\005false\0222\n\"fil"
  "l_tightened_domains_in_response\030\204\001 \001(\010:\005"
  "false\0225\n%fill_additional_solutions_in_re"
  "sponse\030\302\001 \001(\010:\005false\022\'\n\031instantiate_all_"
  "variables\030j \001(\010:\004true\0226\n(auto_detect_gre"
  "ater_than_at_least_one_of\030_ \001(\010:\004true\022(\n"
  "\031stop_after_first_solution\030b \001(\010:\005false\022"
  "#\n\023stop_after_presolve\030\225\001 \001(\010:\005false\022\035\n\022"
  "num_search_workers\030d \001(\005:\0010\022!\n\021interleav"
  "e_search\030\210\001 \001(\010:\005false\022!\n\025interleave_bat"
  "ch_size\030\206\001 \001(\005:\0011\0226\n&reduce_memory_usage"
  "_in_interleave_mode\030\215\001 \001(\010:\005false\022$\n\026sha"
  "re_objective_bounds\030q \001(\010:\004true\022%\n\027share"
  "_level_zero_bounds\030r \001(\010:\004true\022\033\n\014use_ln"
  "s_only\030e \001(\010:\005false\022\036\n\022solution_pool_siz"
  "e\030\301\001 \001(\005:\0013\022\033\n\014use_rins_lns\030\201\001 \001(\010:\004true"
  "\022#\n\024use_feasibility_pump\030\244\001 \001(\010:\004true\022c\n"
  "\013fp_rounding\030\245\001 \001(\01627.operations_researc"
  "h.sat.SatParameters.FPRoundingMethod:\024PR"
  "OPAGATION_ASSISTED\022\"\n\022use_relaxation_lns"
  "\030\226\001 \001(\010:\005false\022$\n\024diversify_lns_params\030\211"
  "\001 \001(\010:\005false\022\037\n\020randomize_search\030g \001(\010:\005"
  "false\022)\n\036search_randomization_tolerance\030"
  "h \001(\003:\0010\022$\n\026use_optional_variables\030l \001(\010"
  ":\004true\022!\n\023use_exact_lp_reason\030m \001(\010:\004tru"
  "e\022#\n\023use_branching_in_lp\030\213\001 \001(\010:\005false\022\'"
  "\n\027use_combined_no_overlap\030\205\001 \001(\010:\005false\022"
  "\"\n\023catch_sigint_signal\030\207\001 \001(\010:\004true\022!\n\022u"
  "se_implied_bounds\030\220\001 \001(\010:\004true\022\"\n\022polish"
  "_lp_solution\030\257\001 \001(\010:\005false\022 \n\021convert_in"
  "tervals\030\261\001 \001(\010:\004true\022\032\n\016symmetry_level\030\267"
  "\001 \001(\005:\0012\022\037\n\rmip_max_bound\030| \001(\001:\0101000000"
  "0\022\032\n\017mip_var_scaling\030} \001(\001:\0011\0220\n!mip_aut"
  "omatically_scale_variables\030\246\001 \001(\010:\004true\022"
  "#\n\024mip_wanted_precision\030~ \001(\001:\0051e-06\022%\n\031"
  "mip_max_activity_exponent\030\177 \001(\005:\00253\022$\n\023m"
  "ip_check_precision\030\200\001 \001(\001:\0060.0001\022/\n mip"
  "_compute_true_objective_bound\030\306\001 \001(\010:\004tr"
  "ue\022\'\n\027mip_max_valid_magnitude\030\307\001 \001(\001:\0051e"
  "+30\"H\n\rVariableOrder\022\014\n\010IN_ORDER\020\000\022\024\n\020IN"
  "_REVERSE_ORDER\020\001\022\023\n\017IN_RANDOM_ORDER\020\002\"\206\001"
  "\n\010Polarity\022\021\n\rPOLARITY_TRUE\020\000\022\022\n\016POLARIT"
  "Y_FALSE\020\001\022\023\n\017POLARITY_RANDOM\020\002\022\032\n\026POLARI"
  "TY_WEIGHTED_SIGN\020\003\022\"\n\036POLARITY_REVERSE_W"
  "EIGHTED_SIGN\020\004\"V\n\035ConflictMinimizationAl"
  "gorithm\022\010\n\004NONE\020\000\022\n\n\006SIMPLE\020\001\022\r\n\tRECURSI"
  "VE\020\002\022\020\n\014EXPERIMENTAL\020\003\"\340\001\n\031BinaryMinizat"
  "ionAlgorithm\022\032\n\026NO_BINARY_MINIMIZATION\020\000"
  "\022\035\n\031BINARY_MINIMIZATION_FIRST\020\001\0227\n3BINAR"
  "Y_MINIMIZATION_FIRST_WITH_TRANSITIVE_RED"
  "UCTION\020\004\022)\n%BINARY_MINIMIZATION_WITH_REA"
  "CHABILITY\020\002\022$\n EXPERIMENTAL_BINARY_MINIM"
  "IZATION\020\003\"R\n\020ClauseProtection\022\023\n\017PROTECT"
  "ION_NONE\020\000\022\025\n\021PROTECTION_ALWAYS\020\001\022\022\n\016PRO"
  "TECTION_LBD\020\002\"5\n\016ClauseOrdering\022\023\n\017CLAUS"
  "E_ACTIVITY\020\000\022\016\n\nCLAUSE_LBD\020\001\"\206\001\n\020Restart"
  "Algorithm\022\016\n\nNO_RESTART\020\000\022\020\n\014LUBY_RESTAR"
  "T\020\001\022\035\n\031DL_MOVING_AVERAGE_RESTART\020\002\022\036\n\032LB"
  "D_MOVING_AVERAGE_RESTART\020\003\022\021\n\rFIXED_REST"
  "ART\020\004\"t\n\025MaxSatAssumptionOrder\022\034\n\030DEFAUL"
  "T_ASSUMPTION_ORDER\020\000\022\035\n\031ORDER_ASSUMPTION"
  "_BY_DEPTH\020\001\022\036\n\032ORDER_ASSUMPTION_BY_WEIGH"
  "T\020\002\"o\n\035MaxSatStratificationAlgorithm\022\027\n\023"
  "STRATIFICATION_NONE\020\000\022\032\n\026STRATIFICATION_"
  "DESCENT\020\001\022\031\n\025STRATIFICATION_ASCENT\020\002\"\260\001\n"
  "\017SearchBranching\022\024\n\020AUTOMATIC_SEARCH\020\000\022\020"
  "\n\014FIXED_SEARCH\020\001\022\024\n\020PORTFOLIO_SEARCH\020\002\022\r"
  "\n\tLP_SEARCH\020\003\022\026\n\022PSEUDO_COST_SEARCH\020\004\022\'\n"
  "#PORTFOLIO_WITH_QUICK_RESTART_SEARCH\020\005\022\017"
  "\n\013HINT_SEARCH\020\006\"h\n\020FPRoundingMethod\022\023\n\017N"
  "EAREST_INTEGER\020\000\022\016\n\nLOCK_BASED\020\001\022\025\n\021ACTI"
  "VE_LOCK_BASED\020\003\022\030\n\024PROPAGATION_ASSISTED\020"
  "\002B/\n\026com.google.ortools.satP\001\252\002\022Google.O"
  "rTools.Sat"
  ;
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto = {
  false, false, 9050, descriptor_table_protodef_ortools_2fsat_2fsat_5fparameters_2eproto, "ortools/sat/sat_parameters.proto", 
  &descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto_once, nullptr, 0, 1,
  schemas, file_default_instances, TableStruct_ortools_2fsat_2fsat_5fparameters_2eproto::offsets,
  file_level_metadata_ortools_2fsat_2fsat_5fparameters_2eproto, file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto, file_level_service_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto_getter() {
  return &descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto;
}
 
// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_ortools_2fsat_2fsat_5fparameters_2eproto(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
namespace operations_research {
namespace sat {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_VariableOrder_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[0];
}
bool SatParameters_VariableOrder_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_VariableOrder SatParameters::IN_ORDER;
constexpr SatParameters_VariableOrder SatParameters::IN_REVERSE_ORDER;
constexpr SatParameters_VariableOrder SatParameters::IN_RANDOM_ORDER;
constexpr SatParameters_VariableOrder SatParameters::VariableOrder_MIN;
constexpr SatParameters_VariableOrder SatParameters::VariableOrder_MAX;
constexpr int SatParameters::VariableOrder_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_Polarity_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[1];
}
bool SatParameters_Polarity_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_Polarity SatParameters::POLARITY_TRUE;
constexpr SatParameters_Polarity SatParameters::POLARITY_FALSE;
constexpr SatParameters_Polarity SatParameters::POLARITY_RANDOM;
constexpr SatParameters_Polarity SatParameters::POLARITY_WEIGHTED_SIGN;
constexpr SatParameters_Polarity SatParameters::POLARITY_REVERSE_WEIGHTED_SIGN;
constexpr SatParameters_Polarity SatParameters::Polarity_MIN;
constexpr SatParameters_Polarity SatParameters::Polarity_MAX;
constexpr int SatParameters::Polarity_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ConflictMinimizationAlgorithm_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[2];
}
bool SatParameters_ConflictMinimizationAlgorithm_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters::NONE;
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters::SIMPLE;
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters::RECURSIVE;
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters::EXPERIMENTAL;
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters::ConflictMinimizationAlgorithm_MIN;
constexpr SatParameters_ConflictMinimizationAlgorithm SatParameters::ConflictMinimizationAlgorithm_MAX;
constexpr int SatParameters::ConflictMinimizationAlgorithm_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_BinaryMinizationAlgorithm_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[3];
}
bool SatParameters_BinaryMinizationAlgorithm_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters::NO_BINARY_MINIMIZATION;
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters::BINARY_MINIMIZATION_FIRST;
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters::BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION;
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters::BINARY_MINIMIZATION_WITH_REACHABILITY;
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters::EXPERIMENTAL_BINARY_MINIMIZATION;
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters::BinaryMinizationAlgorithm_MIN;
constexpr SatParameters_BinaryMinizationAlgorithm SatParameters::BinaryMinizationAlgorithm_MAX;
constexpr int SatParameters::BinaryMinizationAlgorithm_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ClauseProtection_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[4];
}
bool SatParameters_ClauseProtection_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_ClauseProtection SatParameters::PROTECTION_NONE;
constexpr SatParameters_ClauseProtection SatParameters::PROTECTION_ALWAYS;
constexpr SatParameters_ClauseProtection SatParameters::PROTECTION_LBD;
constexpr SatParameters_ClauseProtection SatParameters::ClauseProtection_MIN;
constexpr SatParameters_ClauseProtection SatParameters::ClauseProtection_MAX;
constexpr int SatParameters::ClauseProtection_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_ClauseOrdering_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[5];
}
bool SatParameters_ClauseOrdering_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_ClauseOrdering SatParameters::CLAUSE_ACTIVITY;
constexpr SatParameters_ClauseOrdering SatParameters::CLAUSE_LBD;
constexpr SatParameters_ClauseOrdering SatParameters::ClauseOrdering_MIN;
constexpr SatParameters_ClauseOrdering SatParameters::ClauseOrdering_MAX;
constexpr int SatParameters::ClauseOrdering_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_RestartAlgorithm_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[6];
}
bool SatParameters_RestartAlgorithm_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_RestartAlgorithm SatParameters::NO_RESTART;
constexpr SatParameters_RestartAlgorithm SatParameters::LUBY_RESTART;
constexpr SatParameters_RestartAlgorithm SatParameters::DL_MOVING_AVERAGE_RESTART;
constexpr SatParameters_RestartAlgorithm SatParameters::LBD_MOVING_AVERAGE_RESTART;
constexpr SatParameters_RestartAlgorithm SatParameters::FIXED_RESTART;
constexpr SatParameters_RestartAlgorithm SatParameters::RestartAlgorithm_MIN;
constexpr SatParameters_RestartAlgorithm SatParameters::RestartAlgorithm_MAX;
constexpr int SatParameters::RestartAlgorithm_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_MaxSatAssumptionOrder_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[7];
}
bool SatParameters_MaxSatAssumptionOrder_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_MaxSatAssumptionOrder SatParameters::DEFAULT_ASSUMPTION_ORDER;
constexpr SatParameters_MaxSatAssumptionOrder SatParameters::ORDER_ASSUMPTION_BY_DEPTH;
constexpr SatParameters_MaxSatAssumptionOrder SatParameters::ORDER_ASSUMPTION_BY_WEIGHT;
constexpr SatParameters_MaxSatAssumptionOrder SatParameters::MaxSatAssumptionOrder_MIN;
constexpr SatParameters_MaxSatAssumptionOrder SatParameters::MaxSatAssumptionOrder_MAX;
constexpr int SatParameters::MaxSatAssumptionOrder_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_MaxSatStratificationAlgorithm_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[8];
}
bool SatParameters_MaxSatStratificationAlgorithm_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters::STRATIFICATION_NONE;
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters::STRATIFICATION_DESCENT;
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters::STRATIFICATION_ASCENT;
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters::MaxSatStratificationAlgorithm_MIN;
constexpr SatParameters_MaxSatStratificationAlgorithm SatParameters::MaxSatStratificationAlgorithm_MAX;
constexpr int SatParameters::MaxSatStratificationAlgorithm_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_SearchBranching_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[9];
}
bool SatParameters_SearchBranching_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_SearchBranching SatParameters::AUTOMATIC_SEARCH;
constexpr SatParameters_SearchBranching SatParameters::FIXED_SEARCH;
constexpr SatParameters_SearchBranching SatParameters::PORTFOLIO_SEARCH;
constexpr SatParameters_SearchBranching SatParameters::LP_SEARCH;
constexpr SatParameters_SearchBranching SatParameters::PSEUDO_COST_SEARCH;
constexpr SatParameters_SearchBranching SatParameters::PORTFOLIO_WITH_QUICK_RESTART_SEARCH;
constexpr SatParameters_SearchBranching SatParameters::HINT_SEARCH;
constexpr SatParameters_SearchBranching SatParameters::SearchBranching_MIN;
constexpr SatParameters_SearchBranching SatParameters::SearchBranching_MAX;
constexpr int SatParameters::SearchBranching_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SatParameters_FPRoundingMethod_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto);
  return file_level_enum_descriptors_ortools_2fsat_2fsat_5fparameters_2eproto[10];
}
bool SatParameters_FPRoundingMethod_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}
 
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr SatParameters_FPRoundingMethod SatParameters::NEAREST_INTEGER;
constexpr SatParameters_FPRoundingMethod SatParameters::LOCK_BASED;
constexpr SatParameters_FPRoundingMethod SatParameters::ACTIVE_LOCK_BASED;
constexpr SatParameters_FPRoundingMethod SatParameters::PROPAGATION_ASSISTED;
constexpr SatParameters_FPRoundingMethod SatParameters::FPRoundingMethod_MIN;
constexpr SatParameters_FPRoundingMethod SatParameters::FPRoundingMethod_MAX;
constexpr int SatParameters::FPRoundingMethod_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
 
// ===================================================================
 
class SatParameters::_Internal {
 public:
  using HasBits = decltype(std::declval<SatParameters>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_preferred_variable_order(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_initial_polarity(HasBits* has_bits) {
    (*has_bits)[2] |= 2u;
  }
  static void set_has_use_phase_saving(HasBits* has_bits) {
    (*has_bits)[3] |= 8u;
  }
  static void set_has_polarity_rephase_increment(HasBits* has_bits) {
    (*has_bits)[5] |= 2u;
  }
  static void set_has_random_polarity_ratio(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_random_branches_ratio(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_use_erwa_heuristic(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
  static void set_has_initial_variables_activity(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static void set_has_also_bump_variables_in_conflict_reasons(HasBits* has_bits) {
    (*has_bits)[0] |= 32768u;
  }
  static void set_has_minimization_algorithm(HasBits* has_bits) {
    (*has_bits)[2] |= 4u;
  }
  static void set_has_binary_minimization_algorithm(HasBits* has_bits) {
    (*has_bits)[2] |= 65536u;
  }
  static void set_has_subsumption_during_conflict_analysis(HasBits* has_bits) {
    (*has_bits)[3] |= 16u;
  }
  static void set_has_clause_cleanup_period(HasBits* has_bits) {
    (*has_bits)[2] |= 64u;
  }
  static void set_has_clause_cleanup_target(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_clause_cleanup_ratio(HasBits* has_bits) {
    (*has_bits)[5] |= 32u;
  }
  static void set_has_clause_cleanup_protection(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_clause_cleanup_lbd_bound(HasBits* has_bits) {
    (*has_bits)[2] |= 8388608u;
  }
  static void set_has_clause_cleanup_ordering(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_pb_cleanup_increment(HasBits* has_bits) {
    (*has_bits)[2] |= 131072u;
  }
  static void set_has_pb_cleanup_ratio(HasBits* has_bits) {
    (*has_bits)[2] |= 262144u;
  }
  static void set_has_minimize_with_propagation_restart_period(HasBits* has_bits) {
    (*has_bits)[3] |= 8192u;
  }
  static void set_has_minimize_with_propagation_num_decisions(HasBits* has_bits) {
    (*has_bits)[3] |= 16384u;
  }
  static void set_has_variable_activity_decay(HasBits* has_bits) {
    (*has_bits)[2] |= 8u;
  }
  static void set_has_max_variable_activity_value(HasBits* has_bits) {
    (*has_bits)[2] |= 16u;
  }
  static void set_has_glucose_max_decay(HasBits* has_bits) {
    (*has_bits)[2] |= 512u;
  }
  static void set_has_glucose_decay_increment(HasBits* has_bits) {
    (*has_bits)[2] |= 1024u;
  }
  static void set_has_glucose_decay_increment_period(HasBits* has_bits) {
    (*has_bits)[2] |= 128u;
  }
  static void set_has_clause_activity_decay(HasBits* has_bits) {
    (*has_bits)[2] |= 32u;
  }
  static void set_has_max_clause_activity_value(HasBits* has_bits) {
    (*has_bits)[2] |= 256u;
  }
  static void set_has_default_restart_algorithms(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_restart_period(HasBits* has_bits) {
    (*has_bits)[2] |= 2048u;
  }
  static void set_has_restart_running_window_size(HasBits* has_bits) {
    (*has_bits)[2] |= 33554432u;
  }
  static void set_has_restart_dl_average_ratio(HasBits* has_bits) {
    (*has_bits)[2] |= 16777216u;
  }
  static void set_has_restart_lbd_average_ratio(HasBits* has_bits) {
    (*has_bits)[3] |= 4u;
  }
  static void set_has_use_blocking_restart(HasBits* has_bits) {
    (*has_bits)[0] |= 65536u;
  }
  static void set_has_blocking_restart_window_size(HasBits* has_bits) {
    (*has_bits)[2] |= 67108864u;
  }
  static void set_has_blocking_restart_multiplier(HasBits* has_bits) {
    (*has_bits)[2] |= 134217728u;
  }
  static void set_has_num_conflicts_before_strategy_changes(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static void set_has_strategy_change_increase_ratio(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static void set_has_max_time_in_seconds(HasBits* has_bits) {
    (*has_bits)[2] |= 8192u;
  }
  static void set_has_max_deterministic_time(HasBits* has_bits) {
    (*has_bits)[2] |= 268435456u;
  }
  static void set_has_max_number_of_conflicts(HasBits* has_bits) {
    (*has_bits)[2] |= 16384u;
  }
  static void set_has_max_memory_in_mb(HasBits* has_bits) {
    (*has_bits)[2] |= 32768u;
  }
  static void set_has_absolute_gap_limit(HasBits* has_bits) {
    (*has_bits)[4] |= 2147483648u;
  }
  static void set_has_relative_gap_limit(HasBits* has_bits) {
    (*has_bits)[1] |= 4194304u;
  }
  static void set_has_treat_binary_clauses_separately(HasBits* has_bits) {
    (*has_bits)[3] |= 32u;
  }
  static void set_has_random_seed(HasBits* has_bits) {
    (*has_bits)[2] |= 4096u;
  }
  static void set_has_permute_variable_randomly(HasBits* has_bits) {
    (*has_bits)[0] |= 131072u;
  }
  static void set_has_permute_presolve_constraint_order(HasBits* has_bits) {
    (*has_bits)[1] |= 131072u;
  }
  static void set_has_use_absl_random(HasBits* has_bits) {
    (*has_bits)[1] |= 262144u;
  }
  static void set_has_log_search_progress(HasBits* has_bits) {
    (*has_bits)[1] |= 524288u;
  }
  static void set_has_log_subsolver_statistics(HasBits* has_bits) {
    (*has_bits)[3] |= 64u;
  }
  static void set_has_log_prefix(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_log_to_stdout(HasBits* has_bits) {
    (*has_bits)[3] |= 32768u;
  }
  static void set_has_log_to_response(HasBits* has_bits) {
    (*has_bits)[1] |= 1048576u;
  }
  static void set_has_use_pb_resolution(HasBits* has_bits) {
    (*has_bits)[0] |= 16777216u;
  }
  static void set_has_minimize_reduction_during_pb_resolution(HasBits* has_bits) {
    (*has_bits)[0] |= 33554432u;
  }
  static void set_has_count_assumption_levels_in_lbd(HasBits* has_bits) {
    (*has_bits)[3] |= 65536u;
  }
  static void set_has_presolve_bve_threshold(HasBits* has_bits) {
    (*has_bits)[2] |= 1048576u;
  }
  static void set_has_presolve_bve_clause_weight(HasBits* has_bits) {
    (*has_bits)[2] |= 4194304u;
  }
  static void set_has_presolve_probing_deterministic_time_limit(HasBits* has_bits) {
    (*has_bits)[2] |= 2097152u;
  }
  static void set_has_presolve_blocked_clause(HasBits* has_bits) {
    (*has_bits)[3] |= 131072u;
  }
  static void set_has_presolve_use_bva(HasBits* has_bits) {
    (*has_bits)[3] |= 262144u;
  }
  static void set_has_presolve_bva_threshold(HasBits* has_bits) {
    (*has_bits)[3] |= 2u;
  }
  static void set_has_max_presolve_iterations(HasBits* has_bits) {
    (*has_bits)[4] |= 8192u;
  }
  static void set_has_cp_model_presolve(HasBits* has_bits) {
    (*has_bits)[2] |= 536870912u;
  }
  static void set_has_cp_model_probing_level(HasBits* has_bits) {
    (*has_bits)[3] |= 2097152u;
  }
  static void set_has_cp_model_use_sat_presolve(HasBits* has_bits) {
    (*has_bits)[2] |= 1073741824u;
  }
  static void set_has_use_sat_inprocessing(HasBits* has_bits) {
    (*has_bits)[0] |= 67108864u;
  }
  static void set_has_expand_alldiff_constraints(HasBits* has_bits) {
    (*has_bits)[0] |= 134217728u;
  }
  static void set_has_disable_constraint_expansion(HasBits* has_bits) {
    (*has_bits)[1] |= 268435456u;
  }
  static void set_has_merge_no_overlap_work_limit(HasBits* has_bits) {
    (*has_bits)[4] |= 262144u;
  }
  static void set_has_merge_at_most_one_work_limit(HasBits* has_bits) {
    (*has_bits)[4] |= 16777216u;
  }
  static void set_has_presolve_substitution_level(HasBits* has_bits) {
    (*has_bits)[4] |= 8388608u;
  }
  static void set_has_presolve_extract_integer_enforcement(HasBits* has_bits) {
    (*has_bits)[1] |= 536870912u;
  }
  static void set_has_debug_postsolve_with_full_solver(HasBits* has_bits) {
    (*has_bits)[1] |= 1073741824u;
  }
  static void set_has_debug_max_num_presolve_operations(HasBits* has_bits) {
    (*has_bits)[1] |= 2097152u;
  }
  static void set_has_debug_crash_on_bad_hint(HasBits* has_bits) {
    (*has_bits)[1] |= 2147483648u;
  }
  static void set_has_use_optimization_hints(HasBits* has_bits) {
    (*has_bits)[2] |= 2147483648u;
  }
  static void set_has_minimize_core(HasBits* has_bits) {
    (*has_bits)[3] |= 1u;
  }
  static void set_has_find_multiple_cores(HasBits* has_bits) {
    (*has_bits)[3] |= 128u;
  }
  static void set_has_cover_optimization(HasBits* has_bits) {
    (*has_bits)[3] |= 256u;
  }
  static void set_has_max_sat_assumption_order(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_max_sat_reverse_assumption_order(HasBits* has_bits) {
    (*has_bits)[0] |= 524288u;
  }
  static void set_has_max_sat_stratification(HasBits* has_bits) {
    (*has_bits)[2] |= 524288u;
  }
  static void set_has_use_precedences_in_disjunctive_constraint(HasBits* has_bits) {
    (*has_bits)[3] |= 512u;
  }
  static void set_has_use_overload_checker_in_cumulative_constraint(HasBits* has_bits) {
    (*has_bits)[0] |= 1048576u;
  }
  static void set_has_use_timetable_edge_finding_in_cumulative_constraint(HasBits* has_bits) {
    (*has_bits)[0] |= 2097152u;
  }
  static void set_has_use_disjunctive_constraint_in_cumulative_constraint(HasBits* has_bits) {
    (*has_bits)[3] |= 1024u;
  }
  static void set_has_use_cumulative_in_no_overlap_2d(HasBits* has_bits) {
    (*has_bits)[0] |= 4194304u;
  }
  static void set_has_linearization_level(HasBits* has_bits) {
    (*has_bits)[3] |= 2048u;
  }
  static void set_has_boolean_encoding_level(HasBits* has_bits) {
    (*has_bits)[3] |= 1048576u;
  }
  static void set_has_max_domain_size_when_encoding_eq_neq_constraints(HasBits* has_bits) {
    (*has_bits)[5] |= 64u;
  }
  static void set_has_max_num_cuts(HasBits* has_bits) {
    (*has_bits)[3] |= 4096u;
  }
  static void set_has_cut_level(HasBits* has_bits) {
    (*has_bits)[2] |= 1u;
  }
  static void set_has_only_add_cuts_at_level_zero(HasBits* has_bits) {
    (*has_bits)[1] |= 8388608u;
  }
  static void set_has_add_objective_cut(HasBits* has_bits) {
    (*has_bits)[1] |= 16777216u;
  }
  static void set_has_add_cg_cuts(HasBits* has_bits) {
    (*has_bits)[4] |= 524288u;
  }
  static void set_has_add_mir_cuts(HasBits* has_bits) {
    (*has_bits)[4] |= 1048576u;
  }
  static void set_has_add_zero_half_cuts(HasBits* has_bits) {
    (*has_bits)[4] |= 2097152u;
  }
  static void set_has_add_clique_cuts(HasBits* has_bits) {
    (*has_bits)[4] |= 4194304u;
  }
  static void set_has_max_all_diff_cut_size(HasBits* has_bits) {
    (*has_bits)[4] |= 33554432u;
  }
  static void set_has_add_lin_max_cuts(HasBits* has_bits) {
    (*has_bits)[3] |= 67108864u;
  }
  static void set_has_max_integer_rounding_scaling(HasBits* has_bits) {
    (*has_bits)[3] |= 2147483648u;
  }
  static void set_has_add_lp_constraints_lazily(HasBits* has_bits) {
    (*has_bits)[3] |= 134217728u;
  }
  static void set_has_min_orthogonality_for_lp_constraints(HasBits* has_bits) {
    (*has_bits)[3] |= 1073741824u;
  }
  static void set_has_max_cut_rounds_at_level_zero(HasBits* has_bits) {
    (*has_bits)[4] |= 268435456u;
  }
  static void set_has_max_consecutive_inactive_count(HasBits* has_bits) {
    (*has_bits)[4] |= 1u;
  }
  static void set_has_cut_max_active_count_value(HasBits* has_bits) {
    (*has_bits)[4] |= 134217728u;
  }
  static void set_has_cut_active_count_decay(HasBits* has_bits) {
    (*has_bits)[4] |= 1073741824u;
  }
  static void set_has_cut_cleanup_target(HasBits* has_bits) {
    (*has_bits)[4] |= 536870912u;
  }
  static void set_has_new_constraints_batch_size(HasBits* has_bits) {
    (*has_bits)[4] |= 8u;
  }
  static void set_has_search_branching(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static void set_has_hint_conflict_limit(HasBits* has_bits) {
    (*has_bits)[4] |= 67108864u;
  }
  static void set_has_repair_hint(HasBits* has_bits) {
    (*has_bits)[1] |= 33554432u;
  }
  static void set_has_fix_variables_to_their_hinted_value(HasBits* has_bits) {
    (*has_bits)[1] |= 67108864u;
  }
  static void set_has_exploit_integer_lp_solution(HasBits* has_bits) {
    (*has_bits)[3] |= 268435456u;
  }
  static void set_has_exploit_all_lp_solution(HasBits* has_bits) {
    (*has_bits)[3] |= 536870912u;
  }
  static void set_has_exploit_best_solution(HasBits* has_bits) {
    (*has_bits)[1] |= 256u;
  }
  static void set_has_exploit_relaxation_solution(HasBits* has_bits) {
    (*has_bits)[1] |= 512u;
  }
  static void set_has_exploit_objective(HasBits* has_bits) {
    (*has_bits)[3] |= 4194304u;
  }
  static void set_has_probing_period_at_root(HasBits* has_bits) {
    (*has_bits)[1] |= 65536u;
  }
  static void set_has_use_probing_search(HasBits* has_bits) {
    (*has_bits)[1] |= 1024u;
  }
  static void set_has_pseudo_cost_reliability_threshold(HasBits* has_bits) {
    (*has_bits)[4] |= 2u;
  }
  static void set_has_optimize_with_core(HasBits* has_bits) {
    (*has_bits)[1] |= 2048u;
  }
  static void set_has_optimize_with_lb_tree_search(HasBits* has_bits) {
    (*has_bits)[1] |= 16u;
  }
  static void set_has_binary_search_num_conflicts(HasBits* has_bits) {
    (*has_bits)[3] |= 524288u;
  }
  static void set_has_optimize_with_max_hs(HasBits* has_bits) {
    (*has_bits)[1] |= 32u;
  }
  static void set_has_enumerate_all_solutions(HasBits* has_bits) {
    (*has_bits)[1] |= 64u;
  }
  static void set_has_keep_all_feasible_solutions_in_presolve(HasBits* has_bits) {
    (*has_bits)[1] |= 128u;
  }
  static void set_has_fill_tightened_domains_in_response(HasBits* has_bits) {
    (*has_bits)[1] |= 4096u;
  }
  static void set_has_fill_additional_solutions_in_response(HasBits* has_bits) {
    (*has_bits)[1] |= 8192u;
  }
  static void set_has_instantiate_all_variables(HasBits* has_bits) {
    (*has_bits)[3] |= 8388608u;
  }
  static void set_has_auto_detect_greater_than_at_least_one_of(HasBits* has_bits) {
    (*has_bits)[3] |= 16777216u;
  }
  static void set_has_stop_after_first_solution(HasBits* has_bits) {
    (*has_bits)[1] |= 16384u;
  }
  static void set_has_stop_after_presolve(HasBits* has_bits) {
    (*has_bits)[1] |= 32768u;
  }
  static void set_has_num_search_workers(HasBits* has_bits) {
    (*has_bits)[0] |= 262144u;
  }
  static void set_has_interleave_search(HasBits* has_bits) {
    (*has_bits)[1] |= 1u;
  }
  static void set_has_interleave_batch_size(HasBits* has_bits) {
    (*has_bits)[4] |= 4096u;
  }
  static void set_has_reduce_memory_usage_in_interleave_mode(HasBits* has_bits) {
    (*has_bits)[1] |= 2u;
  }
  static void set_has_share_objective_bounds(HasBits* has_bits) {
    (*has_bits)[3] |= 33554432u;
  }
  static void set_has_share_level_zero_bounds(HasBits* has_bits) {
    (*has_bits)[4] |= 256u;
  }
  static void set_has_use_lns_only(HasBits* has_bits) {
    (*has_bits)[1] |= 4u;
  }
  static void set_has_solution_pool_size(HasBits* has_bits) {
    (*has_bits)[5] |= 128u;
  }
  static void set_has_use_rins_lns(HasBits* has_bits) {
    (*has_bits)[4] |= 512u;
  }
  static void set_has_use_feasibility_pump(HasBits* has_bits) {
    (*has_bits)[4] |= 1024u;
  }
  static void set_has_fp_rounding(HasBits* has_bits) {
    (*has_bits)[5] |= 1u;
  }
  static void set_has_use_relaxation_lns(HasBits* has_bits) {
    (*has_bits)[1] |= 8u;
  }
  static void set_has_diversify_lns_params(HasBits* has_bits) {
    (*has_bits)[0] |= 268435456u;
  }
  static void set_has_randomize_search(HasBits* has_bits) {
    (*has_bits)[0] |= 536870912u;
  }
  static void set_has_search_randomization_tolerance(HasBits* has_bits) {
    (*has_bits)[0] |= 8388608u;
  }
  static void set_has_use_optional_variables(HasBits* has_bits) {
    (*has_bits)[4] |= 2048u;
  }
  static void set_has_use_exact_lp_reason(HasBits* has_bits) {
    (*has_bits)[4] |= 16384u;
  }
  static void set_has_use_branching_in_lp(HasBits* has_bits) {
    (*has_bits)[0] |= 1073741824u;
  }
  static void set_has_use_combined_no_overlap(HasBits* has_bits) {
    (*has_bits)[0] |= 2147483648u;
  }
  static void set_has_catch_sigint_signal(HasBits* has_bits) {
    (*has_bits)[4] |= 32768u;
  }
  static void set_has_use_implied_bounds(HasBits* has_bits) {
    (*has_bits)[4] |= 65536u;
  }
  static void set_has_polish_lp_solution(HasBits* has_bits) {
    (*has_bits)[1] |= 134217728u;
  }
  static void set_has_convert_intervals(HasBits* has_bits) {
    (*has_bits)[4] |= 131072u;
  }
  static void set_has_symmetry_level(HasBits* has_bits) {
    (*has_bits)[5] |= 16u;
  }
  static void set_has_mip_max_bound(HasBits* has_bits) {
    (*has_bits)[4] |= 4u;
  }
  static void set_has_mip_var_scaling(HasBits* has_bits) {
    (*has_bits)[4] |= 32u;
  }
  static void set_has_mip_automatically_scale_variables(HasBits* has_bits) {
    (*has_bits)[5] |= 4u;
  }
  static void set_has_mip_wanted_precision(HasBits* has_bits) {
    (*has_bits)[4] |= 64u;
  }
  static void set_has_mip_max_activity_exponent(HasBits* has_bits) {
    (*has_bits)[4] |= 16u;
  }
  static void set_has_mip_check_precision(HasBits* has_bits) {
    (*has_bits)[4] |= 128u;
  }
  static void set_has_mip_compute_true_objective_bound(HasBits* has_bits) {
    (*has_bits)[5] |= 8u;
  }
  static void set_has_mip_max_valid_magnitude(HasBits* has_bits) {
    (*has_bits)[5] |= 256u;
  }
};
 
const ::PROTOBUF_NAMESPACE_ID::internal::LazyString SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_{{{"LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART", 65}}, {nullptr}};
SatParameters::SatParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  restart_algorithms_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.sat.SatParameters)
}
SatParameters::SatParameters(const SatParameters& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      restart_algorithms_(from.restart_algorithms_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  default_restart_algorithms_.UnsafeSetDefault(nullptr);
  if (from._internal_has_default_restart_algorithms()) {
    default_restart_algorithms_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_default_restart_algorithms(), 
      GetArenaForAllocation());
  }
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_name()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArenaForAllocation());
  }
  log_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
    log_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (from._internal_has_log_prefix()) {
    log_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_log_prefix(), 
      GetArenaForAllocation());
  }
  ::memcpy(&preferred_variable_order_, &from.preferred_variable_order_,
    static_cast<size_t>(reinterpret_cast<char*>(&mip_max_valid_magnitude_) -
    reinterpret_cast<char*>(&preferred_variable_order_)) + sizeof(mip_max_valid_magnitude_));
  // @@protoc_insertion_point(copy_constructor:operations_research.sat.SatParameters)
}
 
inline void SatParameters::SharedCtor() {
default_restart_algorithms_.UnsafeSetDefault(nullptr);
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
log_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  log_prefix_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&preferred_variable_order_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&debug_crash_on_bad_hint_) -
    reinterpret_cast<char*>(&preferred_variable_order_)) + sizeof(debug_crash_on_bad_hint_));
cut_level_ = 1;
initial_polarity_ = 1;
minimization_algorithm_ = 2;
variable_activity_decay_ = 0.8;
max_variable_activity_value_ = 1e+100;
clause_activity_decay_ = 0.999;
clause_cleanup_period_ = 10000;
glucose_decay_increment_period_ = 5000;
max_clause_activity_value_ = 1e+20;
glucose_max_decay_ = 0.95;
glucose_decay_increment_ = 0.01;
restart_period_ = 50;
random_seed_ = 1;
max_time_in_seconds_ = std::numeric_limits<double>::infinity();
max_number_of_conflicts_ = int64_t{9223372036854775807};
max_memory_in_mb_ = int64_t{10000};
binary_minimization_algorithm_ = 1;
pb_cleanup_increment_ = 200;
pb_cleanup_ratio_ = 0.5;
max_sat_stratification_ = 1;
presolve_bve_threshold_ = 500;
presolve_probing_deterministic_time_limit_ = 30;
presolve_bve_clause_weight_ = 3;
clause_cleanup_lbd_bound_ = 5;
restart_dl_average_ratio_ = 1;
restart_running_window_size_ = 50;
blocking_restart_window_size_ = 5000;
blocking_restart_multiplier_ = 1.4;
max_deterministic_time_ = std::numeric_limits<double>::infinity();
cp_model_presolve_ = true;
cp_model_use_sat_presolve_ = true;
use_optimization_hints_ = true;
minimize_core_ = true;
presolve_bva_threshold_ = 1;
restart_lbd_average_ratio_ = 1;
use_phase_saving_ = true;
subsumption_during_conflict_analysis_ = true;
treat_binary_clauses_separately_ = true;
log_subsolver_statistics_ = true;
find_multiple_cores_ = true;
cover_optimization_ = true;
use_precedences_in_disjunctive_constraint_ = true;
use_disjunctive_constraint_in_cumulative_constraint_ = true;
linearization_level_ = 1;
max_num_cuts_ = 10000;
minimize_with_propagation_restart_period_ = 10;
minimize_with_propagation_num_decisions_ = 1000;
log_to_stdout_ = true;
count_assumption_levels_in_lbd_ = true;
presolve_blocked_clause_ = true;
presolve_use_bva_ = true;
binary_search_num_conflicts_ = -1;
boolean_encoding_level_ = 1;
cp_model_probing_level_ = 2;
exploit_objective_ = true;
instantiate_all_variables_ = true;
auto_detect_greater_than_at_least_one_of_ = true;
share_objective_bounds_ = true;
add_lin_max_cuts_ = true;
add_lp_constraints_lazily_ = true;
exploit_integer_lp_solution_ = true;
exploit_all_lp_solution_ = true;
min_orthogonality_for_lp_constraints_ = 0.05;
max_integer_rounding_scaling_ = 600;
max_consecutive_inactive_count_ = 100;
pseudo_cost_reliability_threshold_ = int64_t{100};
mip_max_bound_ = 10000000;
new_constraints_batch_size_ = 50;
mip_max_activity_exponent_ = 53;
mip_var_scaling_ = 1;
mip_wanted_precision_ = 1e-06;
mip_check_precision_ = 0.0001;
share_level_zero_bounds_ = true;
use_rins_lns_ = true;
use_feasibility_pump_ = true;
use_optional_variables_ = true;
interleave_batch_size_ = 1;
max_presolve_iterations_ = 3;
use_exact_lp_reason_ = true;
catch_sigint_signal_ = true;
use_implied_bounds_ = true;
convert_intervals_ = true;
merge_no_overlap_work_limit_ = 1000000000000;
add_cg_cuts_ = true;
add_mir_cuts_ = true;
add_zero_half_cuts_ = true;
add_clique_cuts_ = true;
presolve_substitution_level_ = 1;
merge_at_most_one_work_limit_ = 100000000;
max_all_diff_cut_size_ = 7;
hint_conflict_limit_ = 10;
cut_max_active_count_value_ = 10000000000;
max_cut_rounds_at_level_zero_ = 1;
cut_cleanup_target_ = 1000;
cut_active_count_decay_ = 0.8;
absolute_gap_limit_ = 0.0001;
fp_rounding_ = 2;
polarity_rephase_increment_ = 1000;
mip_automatically_scale_variables_ = true;
mip_compute_true_objective_bound_ = true;
symmetry_level_ = 2;
clause_cleanup_ratio_ = 0.5;
max_domain_size_when_encoding_eq_neq_constraints_ = 16;
solution_pool_size_ = 3;
mip_max_valid_magnitude_ = 1e+30;
}
 
SatParameters::~SatParameters() {
  // @@protoc_insertion_point(destructor:operations_research.sat.SatParameters)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
 
inline void SatParameters::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  default_restart_algorithms_.DestroyNoArena(nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  log_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
 
void SatParameters::ArenaDtor(void* object) {
  SatParameters* _this = reinterpret_cast< SatParameters* >(object);
  (void)_this;
}
void SatParameters::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void SatParameters::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
 
void SatParameters::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.sat.SatParameters)
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  restart_algorithms_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      default_restart_algorithms_.ClearToDefault(::operations_research::sat::SatParameters::_i_give_permission_to_break_this_code_default_default_restart_algorithms_, GetArenaForAllocation());
       }
    if (cached_has_bits & 0x00000002u) {
      name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000004u) {
      log_prefix_.ClearNonDefaultToEmpty();
    }
  }
  if (cached_has_bits & 0x000000f8u) {
    ::memset(&preferred_variable_order_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&max_sat_assumption_order_) -
        reinterpret_cast<char*>(&preferred_variable_order_)) + sizeof(max_sat_assumption_order_));
  }
  if (cached_has_bits & 0x0000ff00u) {
    ::memset(&clause_cleanup_protection_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&also_bump_variables_in_conflict_reasons_) -
        reinterpret_cast<char*>(&clause_cleanup_protection_)) + sizeof(also_bump_variables_in_conflict_reasons_));
  }
  if (cached_has_bits & 0x00ff0000u) {
    ::memset(&use_blocking_restart_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&search_randomization_tolerance_) -
        reinterpret_cast<char*>(&use_blocking_restart_)) + sizeof(search_randomization_tolerance_));
  }
  if (cached_has_bits & 0xff000000u) {
    ::memset(&use_pb_resolution_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&use_combined_no_overlap_) -
        reinterpret_cast<char*>(&use_pb_resolution_)) + sizeof(use_combined_no_overlap_));
  }
  cached_has_bits = _has_bits_[1];
  if (cached_has_bits & 0x000000ffu) {
    ::memset(&interleave_search_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&keep_all_feasible_solutions_in_presolve_) -
        reinterpret_cast<char*>(&interleave_search_)) + sizeof(keep_all_feasible_solutions_in_presolve_));
  }
  if (cached_has_bits & 0x0000ff00u) {
    ::memset(&exploit_best_solution_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&stop_after_presolve_) -
        reinterpret_cast<char*>(&exploit_best_solution_)) + sizeof(stop_after_presolve_));
  }
  if (cached_has_bits & 0x00ff0000u) {
    ::memset(&probing_period_at_root_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&only_add_cuts_at_level_zero_) -
        reinterpret_cast<char*>(&probing_period_at_root_)) + sizeof(only_add_cuts_at_level_zero_));
  }
  if (cached_has_bits & 0xff000000u) {
    ::memset(&add_objective_cut_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&debug_crash_on_bad_hint_) -
        reinterpret_cast<char*>(&add_objective_cut_)) + sizeof(debug_crash_on_bad_hint_));
  }
  cached_has_bits = _has_bits_[2];
  if (cached_has_bits & 0x000000ffu) {
    cut_level_ = 1;
    initial_polarity_ = 1;
    minimization_algorithm_ = 2;
    variable_activity_decay_ = 0.8;
    max_variable_activity_value_ = 1e+100;
    clause_activity_decay_ = 0.999;
    clause_cleanup_period_ = 10000;
    glucose_decay_increment_period_ = 5000;
  }
  if (cached_has_bits & 0x0000ff00u) {
    max_clause_activity_value_ = 1e+20;
    glucose_max_decay_ = 0.95;
    glucose_decay_increment_ = 0.01;
    restart_period_ = 50;
    random_seed_ = 1;
    max_time_in_seconds_ = std::numeric_limits<double>::infinity();
    max_number_of_conflicts_ = int64_t{9223372036854775807};
    max_memory_in_mb_ = int64_t{10000};
  }
  if (cached_has_bits & 0x00ff0000u) {
    binary_minimization_algorithm_ = 1;
    pb_cleanup_increment_ = 200;
    pb_cleanup_ratio_ = 0.5;
    max_sat_stratification_ = 1;
    presolve_bve_threshold_ = 500;
    presolve_probing_deterministic_time_limit_ = 30;
    presolve_bve_clause_weight_ = 3;
    clause_cleanup_lbd_bound_ = 5;
  }
  if (cached_has_bits & 0xff000000u) {
    restart_dl_average_ratio_ = 1;
    restart_running_window_size_ = 50;
    blocking_restart_window_size_ = 5000;
    blocking_restart_multiplier_ = 1.4;
    max_deterministic_time_ = std::numeric_limits<double>::infinity();
    cp_model_presolve_ = true;
    cp_model_use_sat_presolve_ = true;
    use_optimization_hints_ = true;
  }
  cached_has_bits = _has_bits_[3];
  if (cached_has_bits & 0x000000ffu) {
    minimize_core_ = true;
    presolve_bva_threshold_ = 1;
    restart_lbd_average_ratio_ = 1;
    use_phase_saving_ = true;
    subsumption_during_conflict_analysis_ = true;
    treat_binary_clauses_separately_ = true;
    log_subsolver_statistics_ = true;
    find_multiple_cores_ = true;
  }
  if (cached_has_bits & 0x0000ff00u) {
    cover_optimization_ = true;
    use_precedences_in_disjunctive_constraint_ = true;
    use_disjunctive_constraint_in_cumulative_constraint_ = true;
    linearization_level_ = 1;
    max_num_cuts_ = 10000;
    minimize_with_propagation_restart_period_ = 10;
    minimize_with_propagation_num_decisions_ = 1000;
    log_to_stdout_ = true;
  }
  if (cached_has_bits & 0x00ff0000u) {
    count_assumption_levels_in_lbd_ = true;
    presolve_blocked_clause_ = true;
    presolve_use_bva_ = true;
    binary_search_num_conflicts_ = -1;
    boolean_encoding_level_ = 1;
    cp_model_probing_level_ = 2;
    exploit_objective_ = true;
    instantiate_all_variables_ = true;
  }
  if (cached_has_bits & 0xff000000u) {
    auto_detect_greater_than_at_least_one_of_ = true;
    share_objective_bounds_ = true;
    add_lin_max_cuts_ = true;
    add_lp_constraints_lazily_ = true;
    exploit_integer_lp_solution_ = true;
    exploit_all_lp_solution_ = true;
    min_orthogonality_for_lp_constraints_ = 0.05;
    max_integer_rounding_scaling_ = 600;
  }
  cached_has_bits = _has_bits_[4];
  if (cached_has_bits & 0x000000ffu) {
    max_consecutive_inactive_count_ = 100;
    pseudo_cost_reliability_threshold_ = int64_t{100};
    mip_max_bound_ = 10000000;
    new_constraints_batch_size_ = 50;
    mip_max_activity_exponent_ = 53;
    mip_var_scaling_ = 1;
    mip_wanted_precision_ = 1e-06;
    mip_check_precision_ = 0.0001;
  }
  if (cached_has_bits & 0x0000ff00u) {
    share_level_zero_bounds_ = true;
    use_rins_lns_ = true;
    use_feasibility_pump_ = true;
    use_optional_variables_ = true;
    interleave_batch_size_ = 1;
    max_presolve_iterations_ = 3;
    use_exact_lp_reason_ = true;
    catch_sigint_signal_ = true;
  }
  if (cached_has_bits & 0x00ff0000u) {
    use_implied_bounds_ = true;
    convert_intervals_ = true;
    merge_no_overlap_work_limit_ = 1000000000000;
    add_cg_cuts_ = true;
    add_mir_cuts_ = true;
    add_zero_half_cuts_ = true;
    add_clique_cuts_ = true;
    presolve_substitution_level_ = 1;
  }
  if (cached_has_bits & 0xff000000u) {
    merge_at_most_one_work_limit_ = 100000000;
    max_all_diff_cut_size_ = 7;
    hint_conflict_limit_ = 10;
    cut_max_active_count_value_ = 10000000000;
    max_cut_rounds_at_level_zero_ = 1;
    cut_cleanup_target_ = 1000;
    cut_active_count_decay_ = 0.8;
    absolute_gap_limit_ = 0.0001;
  }
  cached_has_bits = _has_bits_[5];
  if (cached_has_bits & 0x000000ffu) {
    fp_rounding_ = 2;
    polarity_rephase_increment_ = 1000;
    mip_automatically_scale_variables_ = true;
    mip_compute_true_objective_bound_ = true;
    symmetry_level_ = 2;
    clause_cleanup_ratio_ = 0.5;
    max_domain_size_when_encoding_eq_neq_constraints_ = 16;
    solution_pool_size_ = 3;
  }
  mip_max_valid_magnitude_ = 1e+30;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}
 
const char* SatParameters::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    uint32_t tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_VariableOrder_IsValid(val))) {
            _internal_set_preferred_variable_order(static_cast<::operations_research::sat::SatParameters_VariableOrder>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_Polarity_IsValid(val))) {
            _internal_set_initial_polarity(static_cast<::operations_research::sat::SatParameters_Polarity>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm_IsValid(val))) {
            _internal_set_minimization_algorithm(static_cast<::operations_research::sat::SatParameters_ConflictMinimizationAlgorithm>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional int32 clause_cleanup_period = 11 [default = 10000];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
          _Internal::set_has_clause_cleanup_period(&_has_bits_);
          clause_cleanup_period_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 clause_cleanup_target = 13 [default = 0];
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
          _Internal::set_has_clause_cleanup_target(&_has_bits_);
          clause_cleanup_target_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double variable_activity_decay = 15 [default = 0.8];
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 121)) {
          _Internal::set_has_variable_activity_decay(&_has_bits_);
          variable_activity_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double max_variable_activity_value = 16 [default = 1e+100];
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 129)) {
          _Internal::set_has_max_variable_activity_value(&_has_bits_);
          max_variable_activity_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double clause_activity_decay = 17 [default = 0.999];
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 137)) {
          _Internal::set_has_clause_activity_decay(&_has_bits_);
          clause_activity_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double max_clause_activity_value = 18 [default = 1e+20];
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 145)) {
          _Internal::set_has_max_clause_activity_value(&_has_bits_);
          max_clause_activity_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double glucose_max_decay = 22 [default = 0.95];
      case 22:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 177)) {
          _Internal::set_has_glucose_max_decay(&_has_bits_);
          glucose_max_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double glucose_decay_increment = 23 [default = 0.01];
      case 23:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 185)) {
          _Internal::set_has_glucose_decay_increment(&_has_bits_);
          glucose_decay_increment_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional int32 glucose_decay_increment_period = 24 [default = 5000];
      case 24:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
          _Internal::set_has_glucose_decay_increment_period(&_has_bits_);
          glucose_decay_increment_period_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 restart_period = 30 [default = 50];
      case 30:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 240)) {
          _Internal::set_has_restart_period(&_has_bits_);
          restart_period_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 random_seed = 31 [default = 1];
      case 31:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
          _Internal::set_has_random_seed(&_has_bits_);
          random_seed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double random_branches_ratio = 32 [default = 0];
      case 32:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 1)) {
          _Internal::set_has_random_branches_ratio(&_has_bits_);
          random_branches_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool treat_binary_clauses_separately = 33 [default = true];
      case 33:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_treat_binary_clauses_separately(&_has_bits_);
          treat_binary_clauses_separately_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
      case 34:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_BinaryMinizationAlgorithm_IsValid(val))) {
            _internal_set_binary_minimization_algorithm(static_cast<::operations_research::sat::SatParameters_BinaryMinizationAlgorithm>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(34, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bool use_optimization_hints = 35 [default = true];
      case 35:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_use_optimization_hints(&_has_bits_);
          use_optimization_hints_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double max_time_in_seconds = 36 [default = inf];
      case 36:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 33)) {
          _Internal::set_has_max_time_in_seconds(&_has_bits_);
          max_time_in_seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
      case 37:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_max_number_of_conflicts(&_has_bits_);
          max_number_of_conflicts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int64 max_memory_in_mb = 40 [default = 10000];
      case 40:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _Internal::set_has_max_memory_in_mb(&_has_bits_);
          max_memory_in_mb_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool log_search_progress = 41 [default = false];
      case 41:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
          _Internal::set_has_log_search_progress(&_has_bits_);
          log_search_progress_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_pb_resolution = 43 [default = false];
      case 43:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
          _Internal::set_has_use_pb_resolution(&_has_bits_);
          use_pb_resolution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_phase_saving = 44 [default = true];
      case 44:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
          _Internal::set_has_use_phase_saving(&_has_bits_);
          use_phase_saving_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double random_polarity_ratio = 45 [default = 0];
      case 45:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 105)) {
          _Internal::set_has_random_polarity_ratio(&_has_bits_);
          random_polarity_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional int32 pb_cleanup_increment = 46 [default = 200];
      case 46:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          _Internal::set_has_pb_cleanup_increment(&_has_bits_);
          pb_cleanup_increment_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double pb_cleanup_ratio = 47 [default = 0.5];
      case 47:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 121)) {
          _Internal::set_has_pb_cleanup_ratio(&_has_bits_);
          pb_cleanup_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
      case 48:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
          _Internal::set_has_minimize_reduction_during_pb_resolution(&_has_bits_);
          minimize_reduction_during_pb_resolution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool count_assumption_levels_in_lbd = 49 [default = true];
      case 49:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
          _Internal::set_has_count_assumption_levels_in_lbd(&_has_bits_);
          count_assumption_levels_in_lbd_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool minimize_core = 50 [default = true];
      case 50:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
          _Internal::set_has_minimize_core(&_has_bits_);
          minimize_core_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
      case 51:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_MaxSatAssumptionOrder_IsValid(val))) {
            _internal_set_max_sat_assumption_order(static_cast<::operations_research::sat::SatParameters_MaxSatAssumptionOrder>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(51, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bool max_sat_reverse_assumption_order = 52 [default = false];
      case 52:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
          _Internal::set_has_max_sat_reverse_assumption_order(&_has_bits_);
          max_sat_reverse_assumption_order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
      case 53:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm_IsValid(val))) {
            _internal_set_max_sat_stratification(static_cast<::operations_research::sat::SatParameters_MaxSatStratificationAlgorithm>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(53, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional int32 presolve_bve_threshold = 54 [default = 500];
      case 54:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
          _Internal::set_has_presolve_bve_threshold(&_has_bits_);
          presolve_bve_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 presolve_bve_clause_weight = 55 [default = 3];
      case 55:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
          _Internal::set_has_presolve_bve_clause_weight(&_has_bits_);
          presolve_bve_clause_weight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool subsumption_during_conflict_analysis = 56 [default = true];
      case 56:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
          _Internal::set_has_subsumption_during_conflict_analysis(&_has_bits_);
          subsumption_during_conflict_analysis_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
      case 57:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 201)) {
          _Internal::set_has_presolve_probing_deterministic_time_limit(&_has_bits_);
          presolve_probing_deterministic_time_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
      case 58:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_ClauseProtection_IsValid(val))) {
            _internal_set_clause_cleanup_protection(static_cast<::operations_research::sat::SatParameters_ClauseProtection>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(58, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
      case 59:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
          _Internal::set_has_clause_cleanup_lbd_bound(&_has_bits_);
          clause_cleanup_lbd_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
      case 60:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 224)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_ClauseOrdering_IsValid(val))) {
            _internal_set_clause_cleanup_ordering(static_cast<::operations_research::sat::SatParameters_ClauseOrdering>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(60, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
      case 61:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
          ptr -= 2;
          do {
            ptr += 2;
            uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
            CHK_(ptr);
            if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_RestartAlgorithm_IsValid(val))) {
              _internal_add_restart_algorithms(static_cast<::operations_research::sat::SatParameters_RestartAlgorithm>(val));
            } else {
              ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(61, val, mutable_unknown_fields());
            }
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<488>(ptr));
        } else if (static_cast<uint8_t>(tag) == 234) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedEnumParser<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(_internal_mutable_restart_algorithms(), ptr, ctx, ::operations_research::sat::SatParameters_RestartAlgorithm_IsValid, &_internal_metadata_, 61);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 restart_running_window_size = 62 [default = 50];
      case 62:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 240)) {
          _Internal::set_has_restart_running_window_size(&_has_bits_);
          restart_running_window_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double restart_dl_average_ratio = 63 [default = 1];
      case 63:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 249)) {
          _Internal::set_has_restart_dl_average_ratio(&_has_bits_);
          restart_dl_average_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_blocking_restart = 64 [default = false];
      case 64:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 0)) {
          _Internal::set_has_use_blocking_restart(&_has_bits_);
          use_blocking_restart_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 blocking_restart_window_size = 65 [default = 5000];
      case 65:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_blocking_restart_window_size(&_has_bits_);
          blocking_restart_window_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double blocking_restart_multiplier = 66 [default = 1.4];
      case 66:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 17)) {
          _Internal::set_has_blocking_restart_multiplier(&_has_bits_);
          blocking_restart_multiplier_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double max_deterministic_time = 67 [default = inf];
      case 67:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 25)) {
          _Internal::set_has_max_deterministic_time(&_has_bits_);
          max_deterministic_time_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
      case 68:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_num_conflicts_before_strategy_changes(&_has_bits_);
          num_conflicts_before_strategy_changes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double strategy_change_increase_ratio = 69 [default = 0];
      case 69:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 41)) {
          _Internal::set_has_strategy_change_increase_ratio(&_has_bits_);
          strategy_change_increase_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
      case 70:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
          auto str = _internal_mutable_default_restart_algorithms();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.sat.SatParameters.default_restart_algorithms");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double restart_lbd_average_ratio = 71 [default = 1];
      case 71:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 57)) {
          _Internal::set_has_restart_lbd_average_ratio(&_has_bits_);
          restart_lbd_average_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool presolve_use_bva = 72 [default = true];
      case 72:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _Internal::set_has_presolve_use_bva(&_has_bits_);
          presolve_use_bva_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 presolve_bva_threshold = 73 [default = 1];
      case 73:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
          _Internal::set_has_presolve_bva_threshold(&_has_bits_);
          presolve_bva_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
      case 74:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
          _Internal::set_has_use_precedences_in_disjunctive_constraint(&_has_bits_);
          use_precedences_in_disjunctive_constraint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_erwa_heuristic = 75 [default = false];
      case 75:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
          _Internal::set_has_use_erwa_heuristic(&_has_bits_);
          use_erwa_heuristic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double initial_variables_activity = 76 [default = 0];
      case 76:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 97)) {
          _Internal::set_has_initial_variables_activity(&_has_bits_);
          initial_variables_activity_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
      case 77:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
          _Internal::set_has_also_bump_variables_in_conflict_reasons(&_has_bits_);
          also_bump_variables_in_conflict_reasons_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
      case 78:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          _Internal::set_has_use_overload_checker_in_cumulative_constraint(&_has_bits_);
          use_overload_checker_in_cumulative_constraint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
      case 79:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
          _Internal::set_has_use_timetable_edge_finding_in_cumulative_constraint(&_has_bits_);
          use_timetable_edge_finding_in_cumulative_constraint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
      case 80:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
          _Internal::set_has_use_disjunctive_constraint_in_cumulative_constraint(&_has_bits_);
          use_disjunctive_constraint_in_cumulative_constraint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
      case 82:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_SearchBranching_IsValid(val))) {
            _internal_set_search_branching(static_cast<::operations_research::sat::SatParameters_SearchBranching>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(82, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bool optimize_with_core = 83 [default = false];
      case 83:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
          _Internal::set_has_optimize_with_core(&_has_bits_);
          optimize_with_core_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool find_multiple_cores = 84 [default = true];
      case 84:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
          _Internal::set_has_find_multiple_cores(&_has_bits_);
          find_multiple_cores_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool optimize_with_max_hs = 85 [default = false];
      case 85:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
          _Internal::set_has_optimize_with_max_hs(&_has_bits_);
          optimize_with_max_hs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool cp_model_presolve = 86 [default = true];
      case 86:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
          _Internal::set_has_cp_model_presolve(&_has_bits_);
          cp_model_presolve_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool enumerate_all_solutions = 87 [default = false];
      case 87:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
          _Internal::set_has_enumerate_all_solutions(&_has_bits_);
          enumerate_all_solutions_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool presolve_blocked_clause = 88 [default = true];
      case 88:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
          _Internal::set_has_presolve_blocked_clause(&_has_bits_);
          presolve_blocked_clause_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool cover_optimization = 89 [default = true];
      case 89:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
          _Internal::set_has_cover_optimization(&_has_bits_);
          cover_optimization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 linearization_level = 90 [default = 1];
      case 90:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
          _Internal::set_has_linearization_level(&_has_bits_);
          linearization_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 max_num_cuts = 91 [default = 10000];
      case 91:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
          _Internal::set_has_max_num_cuts(&_has_bits_);
          max_num_cuts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool only_add_cuts_at_level_zero = 92 [default = false];
      case 92:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 224)) {
          _Internal::set_has_only_add_cuts_at_level_zero(&_has_bits_);
          only_add_cuts_at_level_zero_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool cp_model_use_sat_presolve = 93 [default = true];
      case 93:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
          _Internal::set_has_cp_model_use_sat_presolve(&_has_bits_);
          cp_model_use_sat_presolve_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool exploit_integer_lp_solution = 94 [default = true];
      case 94:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 240)) {
          _Internal::set_has_exploit_integer_lp_solution(&_has_bits_);
          exploit_integer_lp_solution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
      case 95:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
          _Internal::set_has_auto_detect_greater_than_at_least_one_of(&_has_bits_);
          auto_detect_greater_than_at_least_one_of_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
      case 96:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 0)) {
          _Internal::set_has_minimize_with_propagation_restart_period(&_has_bits_);
          minimize_with_propagation_restart_period_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
      case 97:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_minimize_with_propagation_num_decisions(&_has_bits_);
          minimize_with_propagation_num_decisions_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool stop_after_first_solution = 98 [default = false];
      case 98:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_stop_after_first_solution(&_has_bits_);
          stop_after_first_solution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 binary_search_num_conflicts = 99 [default = -1];
      case 99:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_binary_search_num_conflicts(&_has_bits_);
          binary_search_num_conflicts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 num_search_workers = 100 [default = 0];
      case 100:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_num_search_workers(&_has_bits_);
          num_search_workers_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_lns_only = 101 [default = false];
      case 101:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_use_lns_only(&_has_bits_);
          use_lns_only_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool randomize_search = 103 [default = false];
      case 103:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          _Internal::set_has_randomize_search(&_has_bits_);
          randomize_search_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int64 search_randomization_tolerance = 104 [default = 0];
      case 104:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _Internal::set_has_search_randomization_tolerance(&_has_bits_);
          search_randomization_tolerance_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool instantiate_all_variables = 106 [default = true];
      case 106:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
          _Internal::set_has_instantiate_all_variables(&_has_bits_);
          instantiate_all_variables_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 boolean_encoding_level = 107 [default = 1];
      case 107:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
          _Internal::set_has_boolean_encoding_level(&_has_bits_);
          boolean_encoding_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_optional_variables = 108 [default = true];
      case 108:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
          _Internal::set_has_use_optional_variables(&_has_bits_);
          use_optional_variables_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_exact_lp_reason = 109 [default = true];
      case 109:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
          _Internal::set_has_use_exact_lp_reason(&_has_bits_);
          use_exact_lp_reason_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 cp_model_probing_level = 110 [default = 2];
      case 110:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          _Internal::set_has_cp_model_probing_level(&_has_bits_);
          cp_model_probing_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool add_lp_constraints_lazily = 112 [default = true];
      case 112:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
          _Internal::set_has_add_lp_constraints_lazily(&_has_bits_);
          add_lp_constraints_lazily_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool share_objective_bounds = 113 [default = true];
      case 113:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
          _Internal::set_has_share_objective_bounds(&_has_bits_);
          share_objective_bounds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool share_level_zero_bounds = 114 [default = true];
      case 114:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
          _Internal::set_has_share_level_zero_bounds(&_has_bits_);
          share_level_zero_bounds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
      case 115:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 153)) {
          _Internal::set_has_min_orthogonality_for_lp_constraints(&_has_bits_);
          min_orthogonality_for_lp_constraints_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool exploit_all_lp_solution = 116 [default = true];
      case 116:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
          _Internal::set_has_exploit_all_lp_solution(&_has_bits_);
          exploit_all_lp_solution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool add_cg_cuts = 117 [default = true];
      case 117:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
          _Internal::set_has_add_cg_cuts(&_has_bits_);
          add_cg_cuts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 max_integer_rounding_scaling = 119 [default = 600];
      case 119:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
          _Internal::set_has_max_integer_rounding_scaling(&_has_bits_);
          max_integer_rounding_scaling_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool add_mir_cuts = 120 [default = true];
      case 120:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
          _Internal::set_has_add_mir_cuts(&_has_bits_);
          add_mir_cuts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 max_consecutive_inactive_count = 121 [default = 100];
      case 121:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
          _Internal::set_has_max_consecutive_inactive_count(&_has_bits_);
          max_consecutive_inactive_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 new_constraints_batch_size = 122 [default = 50];
      case 122:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
          _Internal::set_has_new_constraints_batch_size(&_has_bits_);
          new_constraints_batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
      case 123:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
          _Internal::set_has_pseudo_cost_reliability_threshold(&_has_bits_);
          pseudo_cost_reliability_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double mip_max_bound = 124 [default = 10000000];
      case 124:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 225)) {
          _Internal::set_has_mip_max_bound(&_has_bits_);
          mip_max_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double mip_var_scaling = 125 [default = 1];
      case 125:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 233)) {
          _Internal::set_has_mip_var_scaling(&_has_bits_);
          mip_var_scaling_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double mip_wanted_precision = 126 [default = 1e-06];
      case 126:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 241)) {
          _Internal::set_has_mip_wanted_precision(&_has_bits_);
          mip_wanted_precision_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional int32 mip_max_activity_exponent = 127 [default = 53];
      case 127:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
          _Internal::set_has_mip_max_activity_exponent(&_has_bits_);
          mip_max_activity_exponent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double mip_check_precision = 128 [default = 0.0001];
      case 128:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 1)) {
          _Internal::set_has_mip_check_precision(&_has_bits_);
          mip_check_precision_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_rins_lns = 129 [default = true];
      case 129:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_use_rins_lns(&_has_bits_);
          use_rins_lns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool exploit_best_solution = 130 [default = false];
      case 130:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_exploit_best_solution(&_has_bits_);
          exploit_best_solution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool exploit_objective = 131 [default = true];
      case 131:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_exploit_objective(&_has_bits_);
          exploit_objective_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool fill_tightened_domains_in_response = 132 [default = false];
      case 132:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_fill_tightened_domains_in_response(&_has_bits_);
          fill_tightened_domains_in_response_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_combined_no_overlap = 133 [default = false];
      case 133:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_use_combined_no_overlap(&_has_bits_);
          use_combined_no_overlap_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 interleave_batch_size = 134 [default = 1];
      case 134:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          _Internal::set_has_interleave_batch_size(&_has_bits_);
          interleave_batch_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool catch_sigint_signal = 135 [default = true];
      case 135:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          _Internal::set_has_catch_sigint_signal(&_has_bits_);
          catch_sigint_signal_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool interleave_search = 136 [default = false];
      case 136:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _Internal::set_has_interleave_search(&_has_bits_);
          interleave_search_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool diversify_lns_params = 137 [default = false];
      case 137:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
          _Internal::set_has_diversify_lns_params(&_has_bits_);
          diversify_lns_params_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 max_presolve_iterations = 138 [default = 3];
      case 138:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
          _Internal::set_has_max_presolve_iterations(&_has_bits_);
          max_presolve_iterations_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_branching_in_lp = 139 [default = false];
      case 139:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 88)) {
          _Internal::set_has_use_branching_in_lp(&_has_bits_);
          use_branching_in_lp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
      case 141:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
          _Internal::set_has_reduce_memory_usage_in_interleave_mode(&_has_bits_);
          reduce_memory_usage_in_interleave_mode_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int64 probing_period_at_root = 142 [default = 0];
      case 142:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          _Internal::set_has_probing_period_at_root(&_has_bits_);
          probing_period_at_root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_implied_bounds = 144 [default = true];
      case 144:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
          _Internal::set_has_use_implied_bounds(&_has_bits_);
          use_implied_bounds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
      case 145:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 137)) {
          _Internal::set_has_merge_no_overlap_work_limit(&_has_bits_);
          merge_no_overlap_work_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
      case 146:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 145)) {
          _Internal::set_has_merge_at_most_one_work_limit(&_has_bits_);
          merge_at_most_one_work_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional int32 presolve_substitution_level = 147 [default = 1];
      case 147:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
          _Internal::set_has_presolve_substitution_level(&_has_bits_);
          presolve_substitution_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 max_all_diff_cut_size = 148 [default = 7];
      case 148:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
          _Internal::set_has_max_all_diff_cut_size(&_has_bits_);
          max_all_diff_cut_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool stop_after_presolve = 149 [default = false];
      case 149:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
          _Internal::set_has_stop_after_presolve(&_has_bits_);
          stop_after_presolve_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_relaxation_lns = 150 [default = false];
      case 150:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 176)) {
          _Internal::set_has_use_relaxation_lns(&_has_bits_);
          use_relaxation_lns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 debug_max_num_presolve_operations = 151 [default = 0];
      case 151:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
          _Internal::set_has_debug_max_num_presolve_operations(&_has_bits_);
          debug_max_num_presolve_operations_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool add_lin_max_cuts = 152 [default = true];
      case 152:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 192)) {
          _Internal::set_has_add_lin_max_cuts(&_has_bits_);
          add_lin_max_cuts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 hint_conflict_limit = 153 [default = 10];
      case 153:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 200)) {
          _Internal::set_has_hint_conflict_limit(&_has_bits_);
          hint_conflict_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
      case 154:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
          _Internal::set_has_max_cut_rounds_at_level_zero(&_has_bits_);
          max_cut_rounds_at_level_zero_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double cut_max_active_count_value = 155 [default = 10000000000];
      case 155:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 217)) {
          _Internal::set_has_cut_max_active_count_value(&_has_bits_);
          cut_max_active_count_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double cut_active_count_decay = 156 [default = 0.8];
      case 156:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 225)) {
          _Internal::set_has_cut_active_count_decay(&_has_bits_);
          cut_active_count_decay_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional int32 cut_cleanup_target = 157 [default = 1000];
      case 157:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
          _Internal::set_has_cut_cleanup_target(&_has_bits_);
          cut_cleanup_target_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double absolute_gap_limit = 159 [default = 0.0001];
      case 159:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 249)) {
          _Internal::set_has_absolute_gap_limit(&_has_bits_);
          absolute_gap_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional double relative_gap_limit = 160 [default = 0];
      case 160:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 1)) {
          _Internal::set_has_relative_gap_limit(&_has_bits_);
          relative_gap_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool exploit_relaxation_solution = 161 [default = false];
      case 161:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_exploit_relaxation_solution(&_has_bits_);
          exploit_relaxation_solution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool debug_postsolve_with_full_solver = 162 [default = false];
      case 162:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_debug_postsolve_with_full_solver(&_has_bits_);
          debug_postsolve_with_full_solver_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_sat_inprocessing = 163 [default = false];
      case 163:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_use_sat_inprocessing(&_has_bits_);
          use_sat_inprocessing_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_feasibility_pump = 164 [default = true];
      case 164:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_use_feasibility_pump(&_has_bits_);
          use_feasibility_pump_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
      case 165:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::sat::SatParameters_FPRoundingMethod_IsValid(val))) {
            _internal_set_fp_rounding(static_cast<::operations_research::sat::SatParameters_FPRoundingMethod>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(165, val, mutable_unknown_fields());
          }
        } else
          goto handle_unusual;
        continue;
      // optional bool mip_automatically_scale_variables = 166 [default = true];
      case 166:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          _Internal::set_has_mip_automatically_scale_variables(&_has_bits_);
          mip_automatically_scale_variables_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool repair_hint = 167 [default = false];
      case 167:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 56)) {
          _Internal::set_has_repair_hint(&_has_bits_);
          repair_hint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 polarity_rephase_increment = 168 [default = 1000];
      case 168:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _Internal::set_has_polarity_rephase_increment(&_has_bits_);
          polarity_rephase_increment_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool add_zero_half_cuts = 169 [default = true];
      case 169:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 72)) {
          _Internal::set_has_add_zero_half_cuts(&_has_bits_);
          add_zero_half_cuts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool expand_alldiff_constraints = 170 [default = false];
      case 170:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 80)) {
          _Internal::set_has_expand_alldiff_constraints(&_has_bits_);
          expand_alldiff_constraints_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string name = 171 [default = ""];
      case 171:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.sat.SatParameters.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool add_clique_cuts = 172 [default = true];
      case 172:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 96)) {
          _Internal::set_has_add_clique_cuts(&_has_bits_);
          add_clique_cuts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
      case 173:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 104)) {
          _Internal::set_has_keep_all_feasible_solutions_in_presolve(&_has_bits_);
          keep_all_feasible_solutions_in_presolve_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool presolve_extract_integer_enforcement = 174 [default = false];
      case 174:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 112)) {
          _Internal::set_has_presolve_extract_integer_enforcement(&_has_bits_);
          presolve_extract_integer_enforcement_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool polish_lp_solution = 175 [default = false];
      case 175:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 120)) {
          _Internal::set_has_polish_lp_solution(&_has_bits_);
          polish_lp_solution_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_probing_search = 176 [default = false];
      case 176:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 128)) {
          _Internal::set_has_use_probing_search(&_has_bits_);
          use_probing_search_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool convert_intervals = 177 [default = true];
      case 177:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 136)) {
          _Internal::set_has_convert_intervals(&_has_bits_);
          convert_intervals_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool permute_variable_randomly = 178 [default = false];
      case 178:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 144)) {
          _Internal::set_has_permute_variable_randomly(&_has_bits_);
          permute_variable_randomly_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool permute_presolve_constraint_order = 179 [default = false];
      case 179:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 152)) {
          _Internal::set_has_permute_presolve_constraint_order(&_has_bits_);
          permute_presolve_constraint_order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_absl_random = 180 [default = false];
      case 180:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 160)) {
          _Internal::set_has_use_absl_random(&_has_bits_);
          use_absl_random_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool disable_constraint_expansion = 181 [default = false];
      case 181:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 168)) {
          _Internal::set_has_disable_constraint_expansion(&_has_bits_);
          disable_constraint_expansion_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 symmetry_level = 183 [default = 2];
      case 183:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 184)) {
          _Internal::set_has_symmetry_level(&_has_bits_);
          symmetry_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional string log_prefix = 185 [default = ""];
      case 185:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 202)) {
          auto str = _internal_mutable_log_prefix();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.sat.SatParameters.log_prefix");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool log_to_stdout = 186 [default = true];
      case 186:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 208)) {
          _Internal::set_has_log_to_stdout(&_has_bits_);
          log_to_stdout_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool log_to_response = 187 [default = false];
      case 187:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 216)) {
          _Internal::set_has_log_to_response(&_has_bits_);
          log_to_response_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool optimize_with_lb_tree_search = 188 [default = false];
      case 188:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 224)) {
          _Internal::set_has_optimize_with_lb_tree_search(&_has_bits_);
          optimize_with_lb_tree_search_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool log_subsolver_statistics = 189 [default = true];
      case 189:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 232)) {
          _Internal::set_has_log_subsolver_statistics(&_has_bits_);
          log_subsolver_statistics_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double clause_cleanup_ratio = 190 [default = 0.5];
      case 190:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 241)) {
          _Internal::set_has_clause_cleanup_ratio(&_has_bits_);
          clause_cleanup_ratio_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional int32 max_domain_size_when_encoding_eq_neq_constraints = 191 [default = 16];
      case 191:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 248)) {
          _Internal::set_has_max_domain_size_when_encoding_eq_neq_constraints(&_has_bits_);
          max_domain_size_when_encoding_eq_neq_constraints_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool fix_variables_to_their_hinted_value = 192 [default = false];
      case 192:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 0)) {
          _Internal::set_has_fix_variables_to_their_hinted_value(&_has_bits_);
          fix_variables_to_their_hinted_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 solution_pool_size = 193 [default = 3];
      case 193:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
          _Internal::set_has_solution_pool_size(&_has_bits_);
          solution_pool_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool fill_additional_solutions_in_response = 194 [default = false];
      case 194:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
          _Internal::set_has_fill_additional_solutions_in_response(&_has_bits_);
          fill_additional_solutions_in_response_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool debug_crash_on_bad_hint = 195 [default = false];
      case 195:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
          _Internal::set_has_debug_crash_on_bad_hint(&_has_bits_);
          debug_crash_on_bad_hint_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional int32 cut_level = 196 [default = 1];
      case 196:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 32)) {
          _Internal::set_has_cut_level(&_has_bits_);
          cut_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool add_objective_cut = 197 [default = false];
      case 197:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 40)) {
          _Internal::set_has_add_objective_cut(&_has_bits_);
          add_objective_cut_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional bool mip_compute_true_objective_bound = 198 [default = true];
      case 198:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 48)) {
          _Internal::set_has_mip_compute_true_objective_bound(&_has_bits_);
          mip_compute_true_objective_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      // optional double mip_max_valid_magnitude = 199 [default = 1e+30];
      case 199:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 57)) {
          _Internal::set_has_mip_max_valid_magnitude(&_has_bits_);
          mip_max_valid_magnitude_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else
          goto handle_unusual;
        continue;
      // optional bool use_cumulative_in_no_overlap_2d = 200 [default = false];
      case 200:
        if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 64)) {
          _Internal::set_has_use_cumulative_in_no_overlap_2d(&_has_bits_);
          use_cumulative_in_no_overlap_2d_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else
          goto handle_unusual;
        continue;
      default:
        goto handle_unusual;
    }  // switch
  handle_unusual:
    if ((tag == 0) || ((tag & 7) == 4)) {
      CHK_(ptr);
      ctx->SetLastTag(tag);
      goto message_done;
    }
    ptr = UnknownFieldParse(
        tag,
        _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
        ptr, ctx);
    CHK_(ptr != nullptr);
  }  // while
message_done:
  return ptr;
failure:
  ptr = nullptr;
  goto message_done;
#undef CHK_
}
 
uint8_t* SatParameters::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.sat.SatParameters)
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;
 
  cached_has_bits = _has_bits_[0];
  // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_preferred_variable_order(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_initial_polarity(), target);
  }
 
  // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_minimization_algorithm(), target);
  }
 
  // optional int32 clause_cleanup_period = 11 [default = 10000];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(11, this->_internal_clause_cleanup_period(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional int32 clause_cleanup_target = 13 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(13, this->_internal_clause_cleanup_target(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional double variable_activity_decay = 15 [default = 0.8];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(15, this->_internal_variable_activity_decay(), target);
  }
 
  // optional double max_variable_activity_value = 16 [default = 1e+100];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(16, this->_internal_max_variable_activity_value(), target);
  }
 
  // optional double clause_activity_decay = 17 [default = 0.999];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(17, this->_internal_clause_activity_decay(), target);
  }
 
  // optional double max_clause_activity_value = 18 [default = 1e+20];
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(18, this->_internal_max_clause_activity_value(), target);
  }
 
  // optional double glucose_max_decay = 22 [default = 0.95];
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(22, this->_internal_glucose_max_decay(), target);
  }
 
  // optional double glucose_decay_increment = 23 [default = 0.01];
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(23, this->_internal_glucose_decay_increment(), target);
  }
 
  // optional int32 glucose_decay_increment_period = 24 [default = 5000];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(24, this->_internal_glucose_decay_increment_period(), target);
  }
 
  // optional int32 restart_period = 30 [default = 50];
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(30, this->_internal_restart_period(), target);
  }
 
  // optional int32 random_seed = 31 [default = 1];
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(31, this->_internal_random_seed(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional double random_branches_ratio = 32 [default = 0];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(32, this->_internal_random_branches_ratio(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool treat_binary_clauses_separately = 33 [default = true];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(33, this->_internal_treat_binary_clauses_separately(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      34, this->_internal_binary_minimization_algorithm(), target);
  }
 
  // optional bool use_optimization_hints = 35 [default = true];
  if (cached_has_bits & 0x80000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(35, this->_internal_use_optimization_hints(), target);
  }
 
  // optional double max_time_in_seconds = 36 [default = inf];
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(36, this->_internal_max_time_in_seconds(), target);
  }
 
  // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(37, this->_internal_max_number_of_conflicts(), target);
  }
 
  // optional int64 max_memory_in_mb = 40 [default = 10000];
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(40, this->_internal_max_memory_in_mb(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool log_search_progress = 41 [default = false];
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(41, this->_internal_log_search_progress(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool use_pb_resolution = 43 [default = false];
  if (cached_has_bits & 0x01000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(43, this->_internal_use_pb_resolution(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool use_phase_saving = 44 [default = true];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(44, this->_internal_use_phase_saving(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional double random_polarity_ratio = 45 [default = 0];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(45, this->_internal_random_polarity_ratio(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional int32 pb_cleanup_increment = 46 [default = 200];
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(46, this->_internal_pb_cleanup_increment(), target);
  }
 
  // optional double pb_cleanup_ratio = 47 [default = 0.5];
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(47, this->_internal_pb_cleanup_ratio(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
  if (cached_has_bits & 0x02000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(48, this->_internal_minimize_reduction_during_pb_resolution(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool count_assumption_levels_in_lbd = 49 [default = true];
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(49, this->_internal_count_assumption_levels_in_lbd(), target);
  }
 
  // optional bool minimize_core = 50 [default = true];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(50, this->_internal_minimize_core(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      51, this->_internal_max_sat_assumption_order(), target);
  }
 
  // optional bool max_sat_reverse_assumption_order = 52 [default = false];
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(52, this->_internal_max_sat_reverse_assumption_order(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      53, this->_internal_max_sat_stratification(), target);
  }
 
  // optional int32 presolve_bve_threshold = 54 [default = 500];
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(54, this->_internal_presolve_bve_threshold(), target);
  }
 
  // optional int32 presolve_bve_clause_weight = 55 [default = 3];
  if (cached_has_bits & 0x00400000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(55, this->_internal_presolve_bve_clause_weight(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool subsumption_during_conflict_analysis = 56 [default = true];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(56, this->_internal_subsumption_during_conflict_analysis(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(57, this->_internal_presolve_probing_deterministic_time_limit(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      58, this->_internal_clause_cleanup_protection(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
  if (cached_has_bits & 0x00800000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(59, this->_internal_clause_cleanup_lbd_bound(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      60, this->_internal_clause_cleanup_ordering(), target);
  }
 
  // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  for (int i = 0, n = this->_internal_restart_algorithms_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
        61, this->_internal_restart_algorithms(i), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional int32 restart_running_window_size = 62 [default = 50];
  if (cached_has_bits & 0x02000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(62, this->_internal_restart_running_window_size(), target);
  }
 
  // optional double restart_dl_average_ratio = 63 [default = 1];
  if (cached_has_bits & 0x01000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(63, this->_internal_restart_dl_average_ratio(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool use_blocking_restart = 64 [default = false];
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(64, this->_internal_use_blocking_restart(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional int32 blocking_restart_window_size = 65 [default = 5000];
  if (cached_has_bits & 0x04000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(65, this->_internal_blocking_restart_window_size(), target);
  }
 
  // optional double blocking_restart_multiplier = 66 [default = 1.4];
  if (cached_has_bits & 0x08000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(66, this->_internal_blocking_restart_multiplier(), target);
  }
 
  // optional double max_deterministic_time = 67 [default = inf];
  if (cached_has_bits & 0x10000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(67, this->_internal_max_deterministic_time(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(68, this->_internal_num_conflicts_before_strategy_changes(), target);
  }
 
  // optional double strategy_change_increase_ratio = 69 [default = 0];
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(69, this->_internal_strategy_change_increase_ratio(), target);
  }
 
  // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_default_restart_algorithms().data(), static_cast<int>(this->_internal_default_restart_algorithms().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.sat.SatParameters.default_restart_algorithms");
    target = stream->WriteStringMaybeAliased(
        70, this->_internal_default_restart_algorithms(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional double restart_lbd_average_ratio = 71 [default = 1];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(71, this->_internal_restart_lbd_average_ratio(), target);
  }
 
  // optional bool presolve_use_bva = 72 [default = true];
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(72, this->_internal_presolve_use_bva(), target);
  }
 
  // optional int32 presolve_bva_threshold = 73 [default = 1];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(73, this->_internal_presolve_bva_threshold(), target);
  }
 
  // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(74, this->_internal_use_precedences_in_disjunctive_constraint(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool use_erwa_heuristic = 75 [default = false];
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(75, this->_internal_use_erwa_heuristic(), target);
  }
 
  // optional double initial_variables_activity = 76 [default = 0];
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(76, this->_internal_initial_variables_activity(), target);
  }
 
  // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(77, this->_internal_also_bump_variables_in_conflict_reasons(), target);
  }
 
  // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(78, this->_internal_use_overload_checker_in_cumulative_constraint(), target);
  }
 
  // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(79, this->_internal_use_timetable_edge_finding_in_cumulative_constraint(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(80, this->_internal_use_disjunctive_constraint_in_cumulative_constraint(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      82, this->_internal_search_branching(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool optimize_with_core = 83 [default = false];
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(83, this->_internal_optimize_with_core(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool find_multiple_cores = 84 [default = true];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(84, this->_internal_find_multiple_cores(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool optimize_with_max_hs = 85 [default = false];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(85, this->_internal_optimize_with_max_hs(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional bool cp_model_presolve = 86 [default = true];
  if (cached_has_bits & 0x20000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(86, this->_internal_cp_model_presolve(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool enumerate_all_solutions = 87 [default = false];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(87, this->_internal_enumerate_all_solutions(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool presolve_blocked_clause = 88 [default = true];
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(88, this->_internal_presolve_blocked_clause(), target);
  }
 
  // optional bool cover_optimization = 89 [default = true];
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(89, this->_internal_cover_optimization(), target);
  }
 
  // optional int32 linearization_level = 90 [default = 1];
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(90, this->_internal_linearization_level(), target);
  }
 
  // optional int32 max_num_cuts = 91 [default = 10000];
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(91, this->_internal_max_num_cuts(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool only_add_cuts_at_level_zero = 92 [default = false];
  if (cached_has_bits & 0x00800000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(92, this->_internal_only_add_cuts_at_level_zero(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional bool cp_model_use_sat_presolve = 93 [default = true];
  if (cached_has_bits & 0x40000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(93, this->_internal_cp_model_use_sat_presolve(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool exploit_integer_lp_solution = 94 [default = true];
  if (cached_has_bits & 0x10000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(94, this->_internal_exploit_integer_lp_solution(), target);
  }
 
  // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
  if (cached_has_bits & 0x01000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(95, this->_internal_auto_detect_greater_than_at_least_one_of(), target);
  }
 
  // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(96, this->_internal_minimize_with_propagation_restart_period(), target);
  }
 
  // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(97, this->_internal_minimize_with_propagation_num_decisions(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool stop_after_first_solution = 98 [default = false];
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(98, this->_internal_stop_after_first_solution(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional int32 binary_search_num_conflicts = 99 [default = -1];
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(99, this->_internal_binary_search_num_conflicts(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional int32 num_search_workers = 100 [default = 0];
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(100, this->_internal_num_search_workers(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool use_lns_only = 101 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(101, this->_internal_use_lns_only(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool randomize_search = 103 [default = false];
  if (cached_has_bits & 0x20000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(103, this->_internal_randomize_search(), target);
  }
 
  // optional int64 search_randomization_tolerance = 104 [default = 0];
  if (cached_has_bits & 0x00800000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(104, this->_internal_search_randomization_tolerance(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool instantiate_all_variables = 106 [default = true];
  if (cached_has_bits & 0x00800000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(106, this->_internal_instantiate_all_variables(), target);
  }
 
  // optional int32 boolean_encoding_level = 107 [default = 1];
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(107, this->_internal_boolean_encoding_level(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool use_optional_variables = 108 [default = true];
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(108, this->_internal_use_optional_variables(), target);
  }
 
  // optional bool use_exact_lp_reason = 109 [default = true];
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(109, this->_internal_use_exact_lp_reason(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional int32 cp_model_probing_level = 110 [default = 2];
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(110, this->_internal_cp_model_probing_level(), target);
  }
 
  // optional bool add_lp_constraints_lazily = 112 [default = true];
  if (cached_has_bits & 0x08000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(112, this->_internal_add_lp_constraints_lazily(), target);
  }
 
  // optional bool share_objective_bounds = 113 [default = true];
  if (cached_has_bits & 0x02000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(113, this->_internal_share_objective_bounds(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool share_level_zero_bounds = 114 [default = true];
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(114, this->_internal_share_level_zero_bounds(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
  if (cached_has_bits & 0x40000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(115, this->_internal_min_orthogonality_for_lp_constraints(), target);
  }
 
  // optional bool exploit_all_lp_solution = 116 [default = true];
  if (cached_has_bits & 0x20000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(116, this->_internal_exploit_all_lp_solution(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool add_cg_cuts = 117 [default = true];
  if (cached_has_bits & 0x00080000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(117, this->_internal_add_cg_cuts(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional int32 max_integer_rounding_scaling = 119 [default = 600];
  if (cached_has_bits & 0x80000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(119, this->_internal_max_integer_rounding_scaling(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool add_mir_cuts = 120 [default = true];
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(120, this->_internal_add_mir_cuts(), target);
  }
 
  // optional int32 max_consecutive_inactive_count = 121 [default = 100];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(121, this->_internal_max_consecutive_inactive_count(), target);
  }
 
  // optional int32 new_constraints_batch_size = 122 [default = 50];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(122, this->_internal_new_constraints_batch_size(), target);
  }
 
  // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(123, this->_internal_pseudo_cost_reliability_threshold(), target);
  }
 
  // optional double mip_max_bound = 124 [default = 10000000];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(124, this->_internal_mip_max_bound(), target);
  }
 
  // optional double mip_var_scaling = 125 [default = 1];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(125, this->_internal_mip_var_scaling(), target);
  }
 
  // optional double mip_wanted_precision = 126 [default = 1e-06];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(126, this->_internal_mip_wanted_precision(), target);
  }
 
  // optional int32 mip_max_activity_exponent = 127 [default = 53];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(127, this->_internal_mip_max_activity_exponent(), target);
  }
 
  // optional double mip_check_precision = 128 [default = 0.0001];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(128, this->_internal_mip_check_precision(), target);
  }
 
  // optional bool use_rins_lns = 129 [default = true];
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(129, this->_internal_use_rins_lns(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool exploit_best_solution = 130 [default = false];
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(130, this->_internal_exploit_best_solution(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool exploit_objective = 131 [default = true];
  if (cached_has_bits & 0x00400000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(131, this->_internal_exploit_objective(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool fill_tightened_domains_in_response = 132 [default = false];
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(132, this->_internal_fill_tightened_domains_in_response(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool use_combined_no_overlap = 133 [default = false];
  if (cached_has_bits & 0x80000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(133, this->_internal_use_combined_no_overlap(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional int32 interleave_batch_size = 134 [default = 1];
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(134, this->_internal_interleave_batch_size(), target);
  }
 
  // optional bool catch_sigint_signal = 135 [default = true];
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(135, this->_internal_catch_sigint_signal(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool interleave_search = 136 [default = false];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(136, this->_internal_interleave_search(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool diversify_lns_params = 137 [default = false];
  if (cached_has_bits & 0x10000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(137, this->_internal_diversify_lns_params(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional int32 max_presolve_iterations = 138 [default = 3];
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(138, this->_internal_max_presolve_iterations(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool use_branching_in_lp = 139 [default = false];
  if (cached_has_bits & 0x40000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(139, this->_internal_use_branching_in_lp(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(141, this->_internal_reduce_memory_usage_in_interleave_mode(), target);
  }
 
  // optional int64 probing_period_at_root = 142 [default = 0];
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(142, this->_internal_probing_period_at_root(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool use_implied_bounds = 144 [default = true];
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(144, this->_internal_use_implied_bounds(), target);
  }
 
  // optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(145, this->_internal_merge_no_overlap_work_limit(), target);
  }
 
  // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
  if (cached_has_bits & 0x01000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(146, this->_internal_merge_at_most_one_work_limit(), target);
  }
 
  // optional int32 presolve_substitution_level = 147 [default = 1];
  if (cached_has_bits & 0x00800000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(147, this->_internal_presolve_substitution_level(), target);
  }
 
  // optional int32 max_all_diff_cut_size = 148 [default = 7];
  if (cached_has_bits & 0x02000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(148, this->_internal_max_all_diff_cut_size(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool stop_after_presolve = 149 [default = false];
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(149, this->_internal_stop_after_presolve(), target);
  }
 
  // optional bool use_relaxation_lns = 150 [default = false];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(150, this->_internal_use_relaxation_lns(), target);
  }
 
  // optional int32 debug_max_num_presolve_operations = 151 [default = 0];
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(151, this->_internal_debug_max_num_presolve_operations(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool add_lin_max_cuts = 152 [default = true];
  if (cached_has_bits & 0x04000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(152, this->_internal_add_lin_max_cuts(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional int32 hint_conflict_limit = 153 [default = 10];
  if (cached_has_bits & 0x04000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(153, this->_internal_hint_conflict_limit(), target);
  }
 
  // optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
  if (cached_has_bits & 0x10000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(154, this->_internal_max_cut_rounds_at_level_zero(), target);
  }
 
  // optional double cut_max_active_count_value = 155 [default = 10000000000];
  if (cached_has_bits & 0x08000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(155, this->_internal_cut_max_active_count_value(), target);
  }
 
  // optional double cut_active_count_decay = 156 [default = 0.8];
  if (cached_has_bits & 0x40000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(156, this->_internal_cut_active_count_decay(), target);
  }
 
  // optional int32 cut_cleanup_target = 157 [default = 1000];
  if (cached_has_bits & 0x20000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(157, this->_internal_cut_cleanup_target(), target);
  }
 
  // optional double absolute_gap_limit = 159 [default = 0.0001];
  if (cached_has_bits & 0x80000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(159, this->_internal_absolute_gap_limit(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional double relative_gap_limit = 160 [default = 0];
  if (cached_has_bits & 0x00400000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(160, this->_internal_relative_gap_limit(), target);
  }
 
  // optional bool exploit_relaxation_solution = 161 [default = false];
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(161, this->_internal_exploit_relaxation_solution(), target);
  }
 
  // optional bool debug_postsolve_with_full_solver = 162 [default = false];
  if (cached_has_bits & 0x40000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(162, this->_internal_debug_postsolve_with_full_solver(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool use_sat_inprocessing = 163 [default = false];
  if (cached_has_bits & 0x04000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(163, this->_internal_use_sat_inprocessing(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool use_feasibility_pump = 164 [default = true];
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(164, this->_internal_use_feasibility_pump(), target);
  }
 
  cached_has_bits = _has_bits_[5];
  // optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      165, this->_internal_fp_rounding(), target);
  }
 
  // optional bool mip_automatically_scale_variables = 166 [default = true];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(166, this->_internal_mip_automatically_scale_variables(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool repair_hint = 167 [default = false];
  if (cached_has_bits & 0x02000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(167, this->_internal_repair_hint(), target);
  }
 
  cached_has_bits = _has_bits_[5];
  // optional int32 polarity_rephase_increment = 168 [default = 1000];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(168, this->_internal_polarity_rephase_increment(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool add_zero_half_cuts = 169 [default = true];
  if (cached_has_bits & 0x00200000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(169, this->_internal_add_zero_half_cuts(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool expand_alldiff_constraints = 170 [default = false];
  if (cached_has_bits & 0x08000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(170, this->_internal_expand_alldiff_constraints(), target);
  }
 
  // optional string name = 171 [default = ""];
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.sat.SatParameters.name");
    target = stream->WriteStringMaybeAliased(
        171, this->_internal_name(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool add_clique_cuts = 172 [default = true];
  if (cached_has_bits & 0x00400000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(172, this->_internal_add_clique_cuts(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(173, this->_internal_keep_all_feasible_solutions_in_presolve(), target);
  }
 
  // optional bool presolve_extract_integer_enforcement = 174 [default = false];
  if (cached_has_bits & 0x20000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(174, this->_internal_presolve_extract_integer_enforcement(), target);
  }
 
  // optional bool polish_lp_solution = 175 [default = false];
  if (cached_has_bits & 0x08000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(175, this->_internal_polish_lp_solution(), target);
  }
 
  // optional bool use_probing_search = 176 [default = false];
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(176, this->_internal_use_probing_search(), target);
  }
 
  cached_has_bits = _has_bits_[4];
  // optional bool convert_intervals = 177 [default = true];
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(177, this->_internal_convert_intervals(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool permute_variable_randomly = 178 [default = false];
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(178, this->_internal_permute_variable_randomly(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool permute_presolve_constraint_order = 179 [default = false];
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(179, this->_internal_permute_presolve_constraint_order(), target);
  }
 
  // optional bool use_absl_random = 180 [default = false];
  if (cached_has_bits & 0x00040000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(180, this->_internal_use_absl_random(), target);
  }
 
  // optional bool disable_constraint_expansion = 181 [default = false];
  if (cached_has_bits & 0x10000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(181, this->_internal_disable_constraint_expansion(), target);
  }
 
  cached_has_bits = _has_bits_[5];
  // optional int32 symmetry_level = 183 [default = 2];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(183, this->_internal_symmetry_level(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional string log_prefix = 185 [default = ""];
  if (cached_has_bits & 0x00000004u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_log_prefix().data(), static_cast<int>(this->_internal_log_prefix().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.sat.SatParameters.log_prefix");
    target = stream->WriteStringMaybeAliased(
        185, this->_internal_log_prefix(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool log_to_stdout = 186 [default = true];
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(186, this->_internal_log_to_stdout(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool log_to_response = 187 [default = false];
  if (cached_has_bits & 0x00100000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(187, this->_internal_log_to_response(), target);
  }
 
  // optional bool optimize_with_lb_tree_search = 188 [default = false];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(188, this->_internal_optimize_with_lb_tree_search(), target);
  }
 
  cached_has_bits = _has_bits_[3];
  // optional bool log_subsolver_statistics = 189 [default = true];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(189, this->_internal_log_subsolver_statistics(), target);
  }
 
  cached_has_bits = _has_bits_[5];
  // optional double clause_cleanup_ratio = 190 [default = 0.5];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(190, this->_internal_clause_cleanup_ratio(), target);
  }
 
  // optional int32 max_domain_size_when_encoding_eq_neq_constraints = 191 [default = 16];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(191, this->_internal_max_domain_size_when_encoding_eq_neq_constraints(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool fix_variables_to_their_hinted_value = 192 [default = false];
  if (cached_has_bits & 0x04000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(192, this->_internal_fix_variables_to_their_hinted_value(), target);
  }
 
  cached_has_bits = _has_bits_[5];
  // optional int32 solution_pool_size = 193 [default = 3];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(193, this->_internal_solution_pool_size(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool fill_additional_solutions_in_response = 194 [default = false];
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(194, this->_internal_fill_additional_solutions_in_response(), target);
  }
 
  // optional bool debug_crash_on_bad_hint = 195 [default = false];
  if (cached_has_bits & 0x80000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(195, this->_internal_debug_crash_on_bad_hint(), target);
  }
 
  cached_has_bits = _has_bits_[2];
  // optional int32 cut_level = 196 [default = 1];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(196, this->_internal_cut_level(), target);
  }
 
  cached_has_bits = _has_bits_[1];
  // optional bool add_objective_cut = 197 [default = false];
  if (cached_has_bits & 0x01000000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(197, this->_internal_add_objective_cut(), target);
  }
 
  cached_has_bits = _has_bits_[5];
  // optional bool mip_compute_true_objective_bound = 198 [default = true];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(198, this->_internal_mip_compute_true_objective_bound(), target);
  }
 
  // optional double mip_max_valid_magnitude = 199 [default = 1e+30];
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(199, this->_internal_mip_max_valid_magnitude(), target);
  }
 
  cached_has_bits = _has_bits_[0];
  // optional bool use_cumulative_in_no_overlap_2d = 200 [default = false];
  if (cached_has_bits & 0x00400000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(200, this->_internal_use_cumulative_in_no_overlap_2d(), target);
  }
 
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.sat.SatParameters)
  return target;
}
 
size_t SatParameters::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.sat.SatParameters)
  size_t total_size = 0;
 
  uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  // repeated .operations_research.sat.SatParameters.RestartAlgorithm restart_algorithms = 61;
  {
    size_t data_size = 0;
    unsigned int count = static_cast<unsigned int>(this->_internal_restart_algorithms_size());for (unsigned int i = 0; i < count; i++) {
      data_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(
        this->_internal_restart_algorithms(static_cast<int>(i)));
    }
    total_size += (2UL * count) + data_size;
  }
 
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string default_restart_algorithms = 70 [default = "LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART"];
    if (cached_has_bits & 0x00000001u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_default_restart_algorithms());
    }
 
    // optional string name = 171 [default = ""];
    if (cached_has_bits & 0x00000002u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }
 
    // optional string log_prefix = 185 [default = ""];
    if (cached_has_bits & 0x00000004u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_log_prefix());
    }
 
    // optional .operations_research.sat.SatParameters.VariableOrder preferred_variable_order = 1 [default = IN_ORDER];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_preferred_variable_order());
    }
 
    // optional int32 clause_cleanup_target = 13 [default = 0];
    if (cached_has_bits & 0x00000010u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_clause_cleanup_target());
    }
 
    // optional double random_branches_ratio = 32 [default = 0];
    if (cached_has_bits & 0x00000020u) {
      total_size += 2 + 8;
    }
 
    // optional double random_polarity_ratio = 45 [default = 0];
    if (cached_has_bits & 0x00000040u) {
      total_size += 2 + 8;
    }
 
    // optional .operations_research.sat.SatParameters.MaxSatAssumptionOrder max_sat_assumption_order = 51 [default = DEFAULT_ASSUMPTION_ORDER];
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_max_sat_assumption_order());
    }
 
  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional .operations_research.sat.SatParameters.ClauseProtection clause_cleanup_protection = 58 [default = PROTECTION_NONE];
    if (cached_has_bits & 0x00000100u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_clause_cleanup_protection());
    }
 
    // optional .operations_research.sat.SatParameters.ClauseOrdering clause_cleanup_ordering = 60 [default = CLAUSE_ACTIVITY];
    if (cached_has_bits & 0x00000200u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_clause_cleanup_ordering());
    }
 
    // optional int32 num_conflicts_before_strategy_changes = 68 [default = 0];
    if (cached_has_bits & 0x00000400u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_num_conflicts_before_strategy_changes());
    }
 
    // optional double strategy_change_increase_ratio = 69 [default = 0];
    if (cached_has_bits & 0x00000800u) {
      total_size += 2 + 8;
    }
 
    // optional double initial_variables_activity = 76 [default = 0];
    if (cached_has_bits & 0x00001000u) {
      total_size += 2 + 8;
    }
 
    // optional .operations_research.sat.SatParameters.SearchBranching search_branching = 82 [default = AUTOMATIC_SEARCH];
    if (cached_has_bits & 0x00002000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_search_branching());
    }
 
    // optional bool use_erwa_heuristic = 75 [default = false];
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 + 1;
    }
 
    // optional bool also_bump_variables_in_conflict_reasons = 77 [default = false];
    if (cached_has_bits & 0x00008000u) {
      total_size += 2 + 1;
    }
 
  }
  if (cached_has_bits & 0x00ff0000u) {
    // optional bool use_blocking_restart = 64 [default = false];
    if (cached_has_bits & 0x00010000u) {
      total_size += 2 + 1;
    }
 
    // optional bool permute_variable_randomly = 178 [default = false];
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 + 1;
    }
 
    // optional int32 num_search_workers = 100 [default = 0];
    if (cached_has_bits & 0x00040000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_num_search_workers());
    }
 
    // optional bool max_sat_reverse_assumption_order = 52 [default = false];
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_overload_checker_in_cumulative_constraint = 78 [default = false];
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_timetable_edge_finding_in_cumulative_constraint = 79 [default = false];
    if (cached_has_bits & 0x00200000u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_cumulative_in_no_overlap_2d = 200 [default = false];
    if (cached_has_bits & 0x00400000u) {
      total_size += 2 + 1;
    }
 
    // optional int64 search_randomization_tolerance = 104 [default = 0];
    if (cached_has_bits & 0x00800000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_search_randomization_tolerance());
    }
 
  }
  if (cached_has_bits & 0xff000000u) {
    // optional bool use_pb_resolution = 43 [default = false];
    if (cached_has_bits & 0x01000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool minimize_reduction_during_pb_resolution = 48 [default = false];
    if (cached_has_bits & 0x02000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_sat_inprocessing = 163 [default = false];
    if (cached_has_bits & 0x04000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool expand_alldiff_constraints = 170 [default = false];
    if (cached_has_bits & 0x08000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool diversify_lns_params = 137 [default = false];
    if (cached_has_bits & 0x10000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool randomize_search = 103 [default = false];
    if (cached_has_bits & 0x20000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_branching_in_lp = 139 [default = false];
    if (cached_has_bits & 0x40000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_combined_no_overlap = 133 [default = false];
    if (cached_has_bits & 0x80000000u) {
      total_size += 2 + 1;
    }
 
  }
  cached_has_bits = _has_bits_[1];
  if (cached_has_bits & 0x000000ffu) {
    // optional bool interleave_search = 136 [default = false];
    if (cached_has_bits & 0x00000001u) {
      total_size += 2 + 1;
    }
 
    // optional bool reduce_memory_usage_in_interleave_mode = 141 [default = false];
    if (cached_has_bits & 0x00000002u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_lns_only = 101 [default = false];
    if (cached_has_bits & 0x00000004u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_relaxation_lns = 150 [default = false];
    if (cached_has_bits & 0x00000008u) {
      total_size += 2 + 1;
    }
 
    // optional bool optimize_with_lb_tree_search = 188 [default = false];
    if (cached_has_bits & 0x00000010u) {
      total_size += 2 + 1;
    }
 
    // optional bool optimize_with_max_hs = 85 [default = false];
    if (cached_has_bits & 0x00000020u) {
      total_size += 2 + 1;
    }
 
    // optional bool enumerate_all_solutions = 87 [default = false];
    if (cached_has_bits & 0x00000040u) {
      total_size += 2 + 1;
    }
 
    // optional bool keep_all_feasible_solutions_in_presolve = 173 [default = false];
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 + 1;
    }
 
  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional bool exploit_best_solution = 130 [default = false];
    if (cached_has_bits & 0x00000100u) {
      total_size += 2 + 1;
    }
 
    // optional bool exploit_relaxation_solution = 161 [default = false];
    if (cached_has_bits & 0x00000200u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_probing_search = 176 [default = false];
    if (cached_has_bits & 0x00000400u) {
      total_size += 2 + 1;
    }
 
    // optional bool optimize_with_core = 83 [default = false];
    if (cached_has_bits & 0x00000800u) {
      total_size += 2 + 1;
    }
 
    // optional bool fill_tightened_domains_in_response = 132 [default = false];
    if (cached_has_bits & 0x00001000u) {
      total_size += 2 + 1;
    }
 
    // optional bool fill_additional_solutions_in_response = 194 [default = false];
    if (cached_has_bits & 0x00002000u) {
      total_size += 2 + 1;
    }
 
    // optional bool stop_after_first_solution = 98 [default = false];
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 + 1;
    }
 
    // optional bool stop_after_presolve = 149 [default = false];
    if (cached_has_bits & 0x00008000u) {
      total_size += 2 + 1;
    }
 
  }
  if (cached_has_bits & 0x00ff0000u) {
    // optional int64 probing_period_at_root = 142 [default = 0];
    if (cached_has_bits & 0x00010000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_probing_period_at_root());
    }
 
    // optional bool permute_presolve_constraint_order = 179 [default = false];
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_absl_random = 180 [default = false];
    if (cached_has_bits & 0x00040000u) {
      total_size += 2 + 1;
    }
 
    // optional bool log_search_progress = 41 [default = false];
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 + 1;
    }
 
    // optional bool log_to_response = 187 [default = false];
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 + 1;
    }
 
    // optional int32 debug_max_num_presolve_operations = 151 [default = 0];
    if (cached_has_bits & 0x00200000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_debug_max_num_presolve_operations());
    }
 
    // optional double relative_gap_limit = 160 [default = 0];
    if (cached_has_bits & 0x00400000u) {
      total_size += 2 + 8;
    }
 
    // optional bool only_add_cuts_at_level_zero = 92 [default = false];
    if (cached_has_bits & 0x00800000u) {
      total_size += 2 + 1;
    }
 
  }
  if (cached_has_bits & 0xff000000u) {
    // optional bool add_objective_cut = 197 [default = false];
    if (cached_has_bits & 0x01000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool repair_hint = 167 [default = false];
    if (cached_has_bits & 0x02000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool fix_variables_to_their_hinted_value = 192 [default = false];
    if (cached_has_bits & 0x04000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool polish_lp_solution = 175 [default = false];
    if (cached_has_bits & 0x08000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool disable_constraint_expansion = 181 [default = false];
    if (cached_has_bits & 0x10000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool presolve_extract_integer_enforcement = 174 [default = false];
    if (cached_has_bits & 0x20000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool debug_postsolve_with_full_solver = 162 [default = false];
    if (cached_has_bits & 0x40000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool debug_crash_on_bad_hint = 195 [default = false];
    if (cached_has_bits & 0x80000000u) {
      total_size += 2 + 1;
    }
 
  }
  cached_has_bits = _has_bits_[2];
  if (cached_has_bits & 0x000000ffu) {
    // optional int32 cut_level = 196 [default = 1];
    if (cached_has_bits & 0x00000001u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_cut_level());
    }
 
    // optional .operations_research.sat.SatParameters.Polarity initial_polarity = 2 [default = POLARITY_FALSE];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_initial_polarity());
    }
 
    // optional .operations_research.sat.SatParameters.ConflictMinimizationAlgorithm minimization_algorithm = 4 [default = RECURSIVE];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_minimization_algorithm());
    }
 
    // optional double variable_activity_decay = 15 [default = 0.8];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }
 
    // optional double max_variable_activity_value = 16 [default = 1e+100];
    if (cached_has_bits & 0x00000010u) {
      total_size += 2 + 8;
    }
 
    // optional double clause_activity_decay = 17 [default = 0.999];
    if (cached_has_bits & 0x00000020u) {
      total_size += 2 + 8;
    }
 
    // optional int32 clause_cleanup_period = 11 [default = 10000];
    if (cached_has_bits & 0x00000040u) {
      total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_clause_cleanup_period());
    }
 
    // optional int32 glucose_decay_increment_period = 24 [default = 5000];
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_glucose_decay_increment_period());
    }
 
  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional double max_clause_activity_value = 18 [default = 1e+20];
    if (cached_has_bits & 0x00000100u) {
      total_size += 2 + 8;
    }
 
    // optional double glucose_max_decay = 22 [default = 0.95];
    if (cached_has_bits & 0x00000200u) {
      total_size += 2 + 8;
    }
 
    // optional double glucose_decay_increment = 23 [default = 0.01];
    if (cached_has_bits & 0x00000400u) {
      total_size += 2 + 8;
    }
 
    // optional int32 restart_period = 30 [default = 50];
    if (cached_has_bits & 0x00000800u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_restart_period());
    }
 
    // optional int32 random_seed = 31 [default = 1];
    if (cached_has_bits & 0x00001000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_random_seed());
    }
 
    // optional double max_time_in_seconds = 36 [default = inf];
    if (cached_has_bits & 0x00002000u) {
      total_size += 2 + 8;
    }
 
    // optional int64 max_number_of_conflicts = 37 [default = 9223372036854775807];
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_max_number_of_conflicts());
    }
 
    // optional int64 max_memory_in_mb = 40 [default = 10000];
    if (cached_has_bits & 0x00008000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_max_memory_in_mb());
    }
 
  }
  if (cached_has_bits & 0x00ff0000u) {
    // optional .operations_research.sat.SatParameters.BinaryMinizationAlgorithm binary_minimization_algorithm = 34 [default = BINARY_MINIMIZATION_FIRST];
    if (cached_has_bits & 0x00010000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_binary_minimization_algorithm());
    }
 
    // optional int32 pb_cleanup_increment = 46 [default = 200];
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_pb_cleanup_increment());
    }
 
    // optional double pb_cleanup_ratio = 47 [default = 0.5];
    if (cached_has_bits & 0x00040000u) {
      total_size += 2 + 8;
    }
 
    // optional .operations_research.sat.SatParameters.MaxSatStratificationAlgorithm max_sat_stratification = 53 [default = STRATIFICATION_DESCENT];
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_max_sat_stratification());
    }
 
    // optional int32 presolve_bve_threshold = 54 [default = 500];
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_presolve_bve_threshold());
    }
 
    // optional double presolve_probing_deterministic_time_limit = 57 [default = 30];
    if (cached_has_bits & 0x00200000u) {
      total_size += 2 + 8;
    }
 
    // optional int32 presolve_bve_clause_weight = 55 [default = 3];
    if (cached_has_bits & 0x00400000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_presolve_bve_clause_weight());
    }
 
    // optional int32 clause_cleanup_lbd_bound = 59 [default = 5];
    if (cached_has_bits & 0x00800000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_clause_cleanup_lbd_bound());
    }
 
  }
  if (cached_has_bits & 0xff000000u) {
    // optional double restart_dl_average_ratio = 63 [default = 1];
    if (cached_has_bits & 0x01000000u) {
      total_size += 2 + 8;
    }
 
    // optional int32 restart_running_window_size = 62 [default = 50];
    if (cached_has_bits & 0x02000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_restart_running_window_size());
    }
 
    // optional int32 blocking_restart_window_size = 65 [default = 5000];
    if (cached_has_bits & 0x04000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_blocking_restart_window_size());
    }
 
    // optional double blocking_restart_multiplier = 66 [default = 1.4];
    if (cached_has_bits & 0x08000000u) {
      total_size += 2 + 8;
    }
 
    // optional double max_deterministic_time = 67 [default = inf];
    if (cached_has_bits & 0x10000000u) {
      total_size += 2 + 8;
    }
 
    // optional bool cp_model_presolve = 86 [default = true];
    if (cached_has_bits & 0x20000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool cp_model_use_sat_presolve = 93 [default = true];
    if (cached_has_bits & 0x40000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_optimization_hints = 35 [default = true];
    if (cached_has_bits & 0x80000000u) {
      total_size += 2 + 1;
    }
 
  }
  cached_has_bits = _has_bits_[3];
  if (cached_has_bits & 0x000000ffu) {
    // optional bool minimize_core = 50 [default = true];
    if (cached_has_bits & 0x00000001u) {
      total_size += 2 + 1;
    }
 
    // optional int32 presolve_bva_threshold = 73 [default = 1];
    if (cached_has_bits & 0x00000002u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_presolve_bva_threshold());
    }
 
    // optional double restart_lbd_average_ratio = 71 [default = 1];
    if (cached_has_bits & 0x00000004u) {
      total_size += 2 + 8;
    }
 
    // optional bool use_phase_saving = 44 [default = true];
    if (cached_has_bits & 0x00000008u) {
      total_size += 2 + 1;
    }
 
    // optional bool subsumption_during_conflict_analysis = 56 [default = true];
    if (cached_has_bits & 0x00000010u) {
      total_size += 2 + 1;
    }
 
    // optional bool treat_binary_clauses_separately = 33 [default = true];
    if (cached_has_bits & 0x00000020u) {
      total_size += 2 + 1;
    }
 
    // optional bool log_subsolver_statistics = 189 [default = true];
    if (cached_has_bits & 0x00000040u) {
      total_size += 2 + 1;
    }
 
    // optional bool find_multiple_cores = 84 [default = true];
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 + 1;
    }
 
  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional bool cover_optimization = 89 [default = true];
    if (cached_has_bits & 0x00000100u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_precedences_in_disjunctive_constraint = 74 [default = true];
    if (cached_has_bits & 0x00000200u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_disjunctive_constraint_in_cumulative_constraint = 80 [default = true];
    if (cached_has_bits & 0x00000400u) {
      total_size += 2 + 1;
    }
 
    // optional int32 linearization_level = 90 [default = 1];
    if (cached_has_bits & 0x00000800u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_linearization_level());
    }
 
    // optional int32 max_num_cuts = 91 [default = 10000];
    if (cached_has_bits & 0x00001000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_max_num_cuts());
    }
 
    // optional int32 minimize_with_propagation_restart_period = 96 [default = 10];
    if (cached_has_bits & 0x00002000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_minimize_with_propagation_restart_period());
    }
 
    // optional int32 minimize_with_propagation_num_decisions = 97 [default = 1000];
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_minimize_with_propagation_num_decisions());
    }
 
    // optional bool log_to_stdout = 186 [default = true];
    if (cached_has_bits & 0x00008000u) {
      total_size += 2 + 1;
    }
 
  }
  if (cached_has_bits & 0x00ff0000u) {
    // optional bool count_assumption_levels_in_lbd = 49 [default = true];
    if (cached_has_bits & 0x00010000u) {
      total_size += 2 + 1;
    }
 
    // optional bool presolve_blocked_clause = 88 [default = true];
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 + 1;
    }
 
    // optional bool presolve_use_bva = 72 [default = true];
    if (cached_has_bits & 0x00040000u) {
      total_size += 2 + 1;
    }
 
    // optional int32 binary_search_num_conflicts = 99 [default = -1];
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_binary_search_num_conflicts());
    }
 
    // optional int32 boolean_encoding_level = 107 [default = 1];
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_boolean_encoding_level());
    }
 
    // optional int32 cp_model_probing_level = 110 [default = 2];
    if (cached_has_bits & 0x00200000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_cp_model_probing_level());
    }
 
    // optional bool exploit_objective = 131 [default = true];
    if (cached_has_bits & 0x00400000u) {
      total_size += 2 + 1;
    }
 
    // optional bool instantiate_all_variables = 106 [default = true];
    if (cached_has_bits & 0x00800000u) {
      total_size += 2 + 1;
    }
 
  }
  if (cached_has_bits & 0xff000000u) {
    // optional bool auto_detect_greater_than_at_least_one_of = 95 [default = true];
    if (cached_has_bits & 0x01000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool share_objective_bounds = 113 [default = true];
    if (cached_has_bits & 0x02000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool add_lin_max_cuts = 152 [default = true];
    if (cached_has_bits & 0x04000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool add_lp_constraints_lazily = 112 [default = true];
    if (cached_has_bits & 0x08000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool exploit_integer_lp_solution = 94 [default = true];
    if (cached_has_bits & 0x10000000u) {
      total_size += 2 + 1;
    }
 
    // optional bool exploit_all_lp_solution = 116 [default = true];
    if (cached_has_bits & 0x20000000u) {
      total_size += 2 + 1;
    }
 
    // optional double min_orthogonality_for_lp_constraints = 115 [default = 0.05];
    if (cached_has_bits & 0x40000000u) {
      total_size += 2 + 8;
    }
 
    // optional int32 max_integer_rounding_scaling = 119 [default = 600];
    if (cached_has_bits & 0x80000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_max_integer_rounding_scaling());
    }
 
  }
  cached_has_bits = _has_bits_[4];
  if (cached_has_bits & 0x000000ffu) {
    // optional int32 max_consecutive_inactive_count = 121 [default = 100];
    if (cached_has_bits & 0x00000001u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_max_consecutive_inactive_count());
    }
 
    // optional int64 pseudo_cost_reliability_threshold = 123 [default = 100];
    if (cached_has_bits & 0x00000002u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
          this->_internal_pseudo_cost_reliability_threshold());
    }
 
    // optional double mip_max_bound = 124 [default = 10000000];
    if (cached_has_bits & 0x00000004u) {
      total_size += 2 + 8;
    }
 
    // optional int32 new_constraints_batch_size = 122 [default = 50];
    if (cached_has_bits & 0x00000008u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_new_constraints_batch_size());
    }
 
    // optional int32 mip_max_activity_exponent = 127 [default = 53];
    if (cached_has_bits & 0x00000010u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_mip_max_activity_exponent());
    }
 
    // optional double mip_var_scaling = 125 [default = 1];
    if (cached_has_bits & 0x00000020u) {
      total_size += 2 + 8;
    }
 
    // optional double mip_wanted_precision = 126 [default = 1e-06];
    if (cached_has_bits & 0x00000040u) {
      total_size += 2 + 8;
    }
 
    // optional double mip_check_precision = 128 [default = 0.0001];
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 + 8;
    }
 
  }
  if (cached_has_bits & 0x0000ff00u) {
    // optional bool share_level_zero_bounds = 114 [default = true];
    if (cached_has_bits & 0x00000100u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_rins_lns = 129 [default = true];
    if (cached_has_bits & 0x00000200u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_feasibility_pump = 164 [default = true];
    if (cached_has_bits & 0x00000400u) {
      total_size += 2 + 1;
    }
 
    // optional bool use_optional_variables = 108 [default = true];
    if (cached_has_bits & 0x00000800u) {
      total_size += 2 + 1;
    }
 
    // optional int32 interleave_batch_size = 134 [default = 1];
    if (cached_has_bits & 0x00001000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_interleave_batch_size());
    }
 
    // optional int32 max_presolve_iterations = 138 [default = 3];
    if (cached_has_bits & 0x00002000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_max_presolve_iterations());
    }
 
    // optional bool use_exact_lp_reason = 109 [default = true];
    if (cached_has_bits & 0x00004000u) {
      total_size += 2 + 1;
    }
 
    // optional bool catch_sigint_signal = 135 [default = true];
    if (cached_has_bits & 0x00008000u) {
      total_size += 2 + 1;
    }
 
  }
  if (cached_has_bits & 0x00ff0000u) {
    // optional bool use_implied_bounds = 144 [default = true];
    if (cached_has_bits & 0x00010000u) {
      total_size += 2 + 1;
    }
 
    // optional bool convert_intervals = 177 [default = true];
    if (cached_has_bits & 0x00020000u) {
      total_size += 2 + 1;
    }
 
    // optional double merge_no_overlap_work_limit = 145 [default = 1000000000000];
    if (cached_has_bits & 0x00040000u) {
      total_size += 2 + 8;
    }
 
    // optional bool add_cg_cuts = 117 [default = true];
    if (cached_has_bits & 0x00080000u) {
      total_size += 2 + 1;
    }
 
    // optional bool add_mir_cuts = 120 [default = true];
    if (cached_has_bits & 0x00100000u) {
      total_size += 2 + 1;
    }
 
    // optional bool add_zero_half_cuts = 169 [default = true];
    if (cached_has_bits & 0x00200000u) {
      total_size += 2 + 1;
    }
 
    // optional bool add_clique_cuts = 172 [default = true];
    if (cached_has_bits & 0x00400000u) {
      total_size += 2 + 1;
    }
 
    // optional int32 presolve_substitution_level = 147 [default = 1];
    if (cached_has_bits & 0x00800000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_presolve_substitution_level());
    }
 
  }
  if (cached_has_bits & 0xff000000u) {
    // optional double merge_at_most_one_work_limit = 146 [default = 100000000];
    if (cached_has_bits & 0x01000000u) {
      total_size += 2 + 8;
    }
 
    // optional int32 max_all_diff_cut_size = 148 [default = 7];
    if (cached_has_bits & 0x02000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_max_all_diff_cut_size());
    }
 
    // optional int32 hint_conflict_limit = 153 [default = 10];
    if (cached_has_bits & 0x04000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_hint_conflict_limit());
    }
 
    // optional double cut_max_active_count_value = 155 [default = 10000000000];
    if (cached_has_bits & 0x08000000u) {
      total_size += 2 + 8;
    }
 
    // optional int32 max_cut_rounds_at_level_zero = 154 [default = 1];
    if (cached_has_bits & 0x10000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_max_cut_rounds_at_level_zero());
    }
 
    // optional int32 cut_cleanup_target = 157 [default = 1000];
    if (cached_has_bits & 0x20000000u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_cut_cleanup_target());
    }
 
    // optional double cut_active_count_decay = 156 [default = 0.8];
    if (cached_has_bits & 0x40000000u) {
      total_size += 2 + 8;
    }
 
    // optional double absolute_gap_limit = 159 [default = 0.0001];
    if (cached_has_bits & 0x80000000u) {
      total_size += 2 + 8;
    }
 
  }
  cached_has_bits = _has_bits_[5];
  if (cached_has_bits & 0x000000ffu) {
    // optional .operations_research.sat.SatParameters.FPRoundingMethod fp_rounding = 165 [default = PROPAGATION_ASSISTED];
    if (cached_has_bits & 0x00000001u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_fp_rounding());
    }
 
    // optional int32 polarity_rephase_increment = 168 [default = 1000];
    if (cached_has_bits & 0x00000002u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_polarity_rephase_increment());
    }
 
    // optional bool mip_automatically_scale_variables = 166 [default = true];
    if (cached_has_bits & 0x00000004u) {
      total_size += 2 + 1;
    }
 
    // optional bool mip_compute_true_objective_bound = 198 [default = true];
    if (cached_has_bits & 0x00000008u) {
      total_size += 2 + 1;
    }
 
    // optional int32 symmetry_level = 183 [default = 2];
    if (cached_has_bits & 0x00000010u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_symmetry_level());
    }
 
    // optional double clause_cleanup_ratio = 190 [default = 0.5];
    if (cached_has_bits & 0x00000020u) {
      total_size += 2 + 8;
    }
 
    // optional int32 max_domain_size_when_encoding_eq_neq_constraints = 191 [default = 16];
    if (cached_has_bits & 0x00000040u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_max_domain_size_when_encoding_eq_neq_constraints());
    }
 
    // optional int32 solution_pool_size = 193 [default = 3];
    if (cached_has_bits & 0x00000080u) {
      total_size += 2 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_solution_pool_size());
    }
 
  }
  // optional double mip_max_valid_magnitude = 199 [default = 1e+30];
  if (cached_has_bits & 0x00000100u) {
    total_size += 2 + 8;
  }
 
  return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
}
 
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SatParameters::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    SatParameters::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SatParameters::GetClassData() const { return &_class_data_; }
 
void SatParameters::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
                      const ::PROTOBUF_NAMESPACE_ID::Message& from) {
  static_cast<SatParameters *>(to)->MergeFrom(
      static_cast<const SatParameters &>(from));
}
 
 
void SatParameters::MergeFrom(const SatParameters& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.sat.SatParameters)
  GOOGLE_DCHECK_NE(&from, this);
  uint32_t cached_has_bits = 0;
  (void) cached_has_bits;
 
  restart_algorithms_.MergeFrom(from.restart_algorithms_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_default_restart_algorithms(from._internal_default_restart_algorithms());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_set_log_prefix(from._internal_log_prefix());
    }
    if (cached_has_bits & 0x00000008u) {
      preferred_variable_order_ = from.preferred_variable_order_;
    }
    if (cached_has_bits & 0x00000010u) {
      clause_cleanup_target_ = from.clause_cleanup_target_;
    }
    if (cached_has_bits & 0x00000020u) {
      random_branches_ratio_ = from.random_branches_ratio_;
    }
    if (cached_has_bits & 0x00000040u) {
      random_polarity_ratio_ = from.random_polarity_ratio_;
    }
    if (cached_has_bits & 0x00000080u) {
      max_sat_assumption_order_ = from.max_sat_assumption_order_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      clause_cleanup_protection_ = from.clause_cleanup_protection_;
    }
    if (cached_has_bits & 0x00000200u) {
      clause_cleanup_ordering_ = from.clause_cleanup_ordering_;
    }
    if (cached_has_bits & 0x00000400u) {
      num_conflicts_before_strategy_changes_ = from.num_conflicts_before_strategy_changes_;
    }
    if (cached_has_bits & 0x00000800u) {
      strategy_change_increase_ratio_ = from.strategy_change_increase_ratio_;
    }
    if (cached_has_bits & 0x00001000u) {
      initial_variables_activity_ = from.initial_variables_activity_;
    }
    if (cached_has_bits & 0x00002000u) {
      search_branching_ = from.search_branching_;
    }
    if (cached_has_bits & 0x00004000u) {
      use_erwa_heuristic_ = from.use_erwa_heuristic_;
    }
    if (cached_has_bits & 0x00008000u) {
      also_bump_variables_in_conflict_reasons_ = from.also_bump_variables_in_conflict_reasons_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      use_blocking_restart_ = from.use_blocking_restart_;
    }
    if (cached_has_bits & 0x00020000u) {
      permute_variable_randomly_ = from.permute_variable_randomly_;
    }
    if (cached_has_bits & 0x00040000u) {
      num_search_workers_ = from.num_search_workers_;
    }
    if (cached_has_bits & 0x00080000u) {
      max_sat_reverse_assumption_order_ = from.max_sat_reverse_assumption_order_;
    }
    if (cached_has_bits & 0x00100000u) {
      use_overload_checker_in_cumulative_constraint_ = from.use_overload_checker_in_cumulative_constraint_;
    }
    if (cached_has_bits & 0x00200000u) {
      use_timetable_edge_finding_in_cumulative_constraint_ = from.use_timetable_edge_finding_in_cumulative_constraint_;
    }
    if (cached_has_bits & 0x00400000u) {
      use_cumulative_in_no_overlap_2d_ = from.use_cumulative_in_no_overlap_2d_;
    }
    if (cached_has_bits & 0x00800000u) {
      search_randomization_tolerance_ = from.search_randomization_tolerance_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0xff000000u) {
    if (cached_has_bits & 0x01000000u) {
      use_pb_resolution_ = from.use_pb_resolution_;
    }
    if (cached_has_bits & 0x02000000u) {
      minimize_reduction_during_pb_resolution_ = from.minimize_reduction_during_pb_resolution_;
    }
    if (cached_has_bits & 0x04000000u) {
      use_sat_inprocessing_ = from.use_sat_inprocessing_;
    }
    if (cached_has_bits & 0x08000000u) {
      expand_alldiff_constraints_ = from.expand_alldiff_constraints_;
    }
    if (cached_has_bits & 0x10000000u) {
      diversify_lns_params_ = from.diversify_lns_params_;
    }
    if (cached_has_bits & 0x20000000u) {
      randomize_search_ = from.randomize_search_;
    }
    if (cached_has_bits & 0x40000000u) {
      use_branching_in_lp_ = from.use_branching_in_lp_;
    }
    if (cached_has_bits & 0x80000000u) {
      use_combined_no_overlap_ = from.use_combined_no_overlap_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  cached_has_bits = from._has_bits_[1];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      interleave_search_ = from.interleave_search_;
    }
    if (cached_has_bits & 0x00000002u) {
      reduce_memory_usage_in_interleave_mode_ = from.reduce_memory_usage_in_interleave_mode_;
    }
    if (cached_has_bits & 0x00000004u) {
      use_lns_only_ = from.use_lns_only_;
    }
    if (cached_has_bits & 0x00000008u) {
      use_relaxation_lns_ = from.use_relaxation_lns_;
    }
    if (cached_has_bits & 0x00000010u) {
      optimize_with_lb_tree_search_ = from.optimize_with_lb_tree_search_;
    }
    if (cached_has_bits & 0x00000020u) {
      optimize_with_max_hs_ = from.optimize_with_max_hs_;
    }
    if (cached_has_bits & 0x00000040u) {
      enumerate_all_solutions_ = from.enumerate_all_solutions_;
    }
    if (cached_has_bits & 0x00000080u) {
      keep_all_feasible_solutions_in_presolve_ = from.keep_all_feasible_solutions_in_presolve_;
    }
    _has_bits_[1] |= cached_has_bits;
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      exploit_best_solution_ = from.exploit_best_solution_;
    }
    if (cached_has_bits & 0x00000200u) {
      exploit_relaxation_solution_ = from.exploit_relaxation_solution_;
    }
    if (cached_has_bits & 0x00000400u) {
      use_probing_search_ = from.use_probing_search_;
    }
    if (cached_has_bits & 0x00000800u) {
      optimize_with_core_ = from.optimize_with_core_;
    }
    if (cached_has_bits & 0x00001000u) {
      fill_tightened_domains_in_response_ = from.fill_tightened_domains_in_response_;
    }
    if (cached_has_bits & 0x00002000u) {
      fill_additional_solutions_in_response_ = from.fill_additional_solutions_in_response_;
    }
    if (cached_has_bits & 0x00004000u) {
      stop_after_first_solution_ = from.stop_after_first_solution_;
    }
    if (cached_has_bits & 0x00008000u) {
      stop_after_presolve_ = from.stop_after_presolve_;
    }
    _has_bits_[1] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      probing_period_at_root_ = from.probing_period_at_root_;
    }
    if (cached_has_bits & 0x00020000u) {
      permute_presolve_constraint_order_ = from.permute_presolve_constraint_order_;
    }
    if (cached_has_bits & 0x00040000u) {
      use_absl_random_ = from.use_absl_random_;
    }
    if (cached_has_bits & 0x00080000u) {
      log_search_progress_ = from.log_search_progress_;
    }
    if (cached_has_bits & 0x00100000u) {
      log_to_response_ = from.log_to_response_;
    }
    if (cached_has_bits & 0x00200000u) {
      debug_max_num_presolve_operations_ = from.debug_max_num_presolve_operations_;
    }
    if (cached_has_bits & 0x00400000u) {
      relative_gap_limit_ = from.relative_gap_limit_;
    }
    if (cached_has_bits & 0x00800000u) {
      only_add_cuts_at_level_zero_ = from.only_add_cuts_at_level_zero_;
    }
    _has_bits_[1] |= cached_has_bits;
  }
  if (cached_has_bits & 0xff000000u) {
    if (cached_has_bits & 0x01000000u) {
      add_objective_cut_ = from.add_objective_cut_;
    }
    if (cached_has_bits & 0x02000000u) {
      repair_hint_ = from.repair_hint_;
    }
    if (cached_has_bits & 0x04000000u) {
      fix_variables_to_their_hinted_value_ = from.fix_variables_to_their_hinted_value_;
    }
    if (cached_has_bits & 0x08000000u) {
      polish_lp_solution_ = from.polish_lp_solution_;
    }
    if (cached_has_bits & 0x10000000u) {
      disable_constraint_expansion_ = from.disable_constraint_expansion_;
    }
    if (cached_has_bits & 0x20000000u) {
      presolve_extract_integer_enforcement_ = from.presolve_extract_integer_enforcement_;
    }
    if (cached_has_bits & 0x40000000u) {
      debug_postsolve_with_full_solver_ = from.debug_postsolve_with_full_solver_;
    }
    if (cached_has_bits & 0x80000000u) {
      debug_crash_on_bad_hint_ = from.debug_crash_on_bad_hint_;
    }
    _has_bits_[1] |= cached_has_bits;
  }
  cached_has_bits = from._has_bits_[2];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      cut_level_ = from.cut_level_;
    }
    if (cached_has_bits & 0x00000002u) {
      initial_polarity_ = from.initial_polarity_;
    }
    if (cached_has_bits & 0x00000004u) {
      minimization_algorithm_ = from.minimization_algorithm_;
    }
    if (cached_has_bits & 0x00000008u) {
      variable_activity_decay_ = from.variable_activity_decay_;
    }
    if (cached_has_bits & 0x00000010u) {
      max_variable_activity_value_ = from.max_variable_activity_value_;
    }
    if (cached_has_bits & 0x00000020u) {
      clause_activity_decay_ = from.clause_activity_decay_;
    }
    if (cached_has_bits & 0x00000040u) {
      clause_cleanup_period_ = from.clause_cleanup_period_;
    }
    if (cached_has_bits & 0x00000080u) {
      glucose_decay_increment_period_ = from.glucose_decay_increment_period_;
    }
    _has_bits_[2] |= cached_has_bits;
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      max_clause_activity_value_ = from.max_clause_activity_value_;
    }
    if (cached_has_bits & 0x00000200u) {
      glucose_max_decay_ = from.glucose_max_decay_;
    }
    if (cached_has_bits & 0x00000400u) {
      glucose_decay_increment_ = from.glucose_decay_increment_;
    }
    if (cached_has_bits & 0x00000800u) {
      restart_period_ = from.restart_period_;
    }
    if (cached_has_bits & 0x00001000u) {
      random_seed_ = from.random_seed_;
    }
    if (cached_has_bits & 0x00002000u) {
      max_time_in_seconds_ = from.max_time_in_seconds_;
    }
    if (cached_has_bits & 0x00004000u) {
      max_number_of_conflicts_ = from.max_number_of_conflicts_;
    }
    if (cached_has_bits & 0x00008000u) {
      max_memory_in_mb_ = from.max_memory_in_mb_;
    }
    _has_bits_[2] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      binary_minimization_algorithm_ = from.binary_minimization_algorithm_;
    }
    if (cached_has_bits & 0x00020000u) {
      pb_cleanup_increment_ = from.pb_cleanup_increment_;
    }
    if (cached_has_bits & 0x00040000u) {
      pb_cleanup_ratio_ = from.pb_cleanup_ratio_;
    }
    if (cached_has_bits & 0x00080000u) {
      max_sat_stratification_ = from.max_sat_stratification_;
    }
    if (cached_has_bits & 0x00100000u) {
      presolve_bve_threshold_ = from.presolve_bve_threshold_;
    }
    if (cached_has_bits & 0x00200000u) {
      presolve_probing_deterministic_time_limit_ = from.presolve_probing_deterministic_time_limit_;
    }
    if (cached_has_bits & 0x00400000u) {
      presolve_bve_clause_weight_ = from.presolve_bve_clause_weight_;
    }
    if (cached_has_bits & 0x00800000u) {
      clause_cleanup_lbd_bound_ = from.clause_cleanup_lbd_bound_;
    }
    _has_bits_[2] |= cached_has_bits;
  }
  if (cached_has_bits & 0xff000000u) {
    if (cached_has_bits & 0x01000000u) {
      restart_dl_average_ratio_ = from.restart_dl_average_ratio_;
    }
    if (cached_has_bits & 0x02000000u) {
      restart_running_window_size_ = from.restart_running_window_size_;
    }
    if (cached_has_bits & 0x04000000u) {
      blocking_restart_window_size_ = from.blocking_restart_window_size_;
    }
    if (cached_has_bits & 0x08000000u) {
      blocking_restart_multiplier_ = from.blocking_restart_multiplier_;
    }
    if (cached_has_bits & 0x10000000u) {
      max_deterministic_time_ = from.max_deterministic_time_;
    }
    if (cached_has_bits & 0x20000000u) {
      cp_model_presolve_ = from.cp_model_presolve_;
    }
    if (cached_has_bits & 0x40000000u) {
      cp_model_use_sat_presolve_ = from.cp_model_use_sat_presolve_;
    }
    if (cached_has_bits & 0x80000000u) {
      use_optimization_hints_ = from.use_optimization_hints_;
    }
    _has_bits_[2] |= cached_has_bits;
  }
  cached_has_bits = from._has_bits_[3];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      minimize_core_ = from.minimize_core_;
    }
    if (cached_has_bits & 0x00000002u) {
      presolve_bva_threshold_ = from.presolve_bva_threshold_;
    }
    if (cached_has_bits & 0x00000004u) {
      restart_lbd_average_ratio_ = from.restart_lbd_average_ratio_;
    }
    if (cached_has_bits & 0x00000008u) {
      use_phase_saving_ = from.use_phase_saving_;
    }
    if (cached_has_bits & 0x00000010u) {
      subsumption_during_conflict_analysis_ = from.subsumption_during_conflict_analysis_;
    }
    if (cached_has_bits & 0x00000020u) {
      treat_binary_clauses_separately_ = from.treat_binary_clauses_separately_;
    }
    if (cached_has_bits & 0x00000040u) {
      log_subsolver_statistics_ = from.log_subsolver_statistics_;
    }
    if (cached_has_bits & 0x00000080u) {
      find_multiple_cores_ = from.find_multiple_cores_;
    }
    _has_bits_[3] |= cached_has_bits;
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      cover_optimization_ = from.cover_optimization_;
    }
    if (cached_has_bits & 0x00000200u) {
      use_precedences_in_disjunctive_constraint_ = from.use_precedences_in_disjunctive_constraint_;
    }
    if (cached_has_bits & 0x00000400u) {
      use_disjunctive_constraint_in_cumulative_constraint_ = from.use_disjunctive_constraint_in_cumulative_constraint_;
    }
    if (cached_has_bits & 0x00000800u) {
      linearization_level_ = from.linearization_level_;
    }
    if (cached_has_bits & 0x00001000u) {
      max_num_cuts_ = from.max_num_cuts_;
    }
    if (cached_has_bits & 0x00002000u) {
      minimize_with_propagation_restart_period_ = from.minimize_with_propagation_restart_period_;
    }
    if (cached_has_bits & 0x00004000u) {
      minimize_with_propagation_num_decisions_ = from.minimize_with_propagation_num_decisions_;
    }
    if (cached_has_bits & 0x00008000u) {
      log_to_stdout_ = from.log_to_stdout_;
    }
    _has_bits_[3] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      count_assumption_levels_in_lbd_ = from.count_assumption_levels_in_lbd_;
    }
    if (cached_has_bits & 0x00020000u) {
      presolve_blocked_clause_ = from.presolve_blocked_clause_;
    }
    if (cached_has_bits & 0x00040000u) {
      presolve_use_bva_ = from.presolve_use_bva_;
    }
    if (cached_has_bits & 0x00080000u) {
      binary_search_num_conflicts_ = from.binary_search_num_conflicts_;
    }
    if (cached_has_bits & 0x00100000u) {
      boolean_encoding_level_ = from.boolean_encoding_level_;
    }
    if (cached_has_bits & 0x00200000u) {
      cp_model_probing_level_ = from.cp_model_probing_level_;
    }
    if (cached_has_bits & 0x00400000u) {
      exploit_objective_ = from.exploit_objective_;
    }
    if (cached_has_bits & 0x00800000u) {
      instantiate_all_variables_ = from.instantiate_all_variables_;
    }
    _has_bits_[3] |= cached_has_bits;
  }
  if (cached_has_bits & 0xff000000u) {
    if (cached_has_bits & 0x01000000u) {
      auto_detect_greater_than_at_least_one_of_ = from.auto_detect_greater_than_at_least_one_of_;
    }
    if (cached_has_bits & 0x02000000u) {
      share_objective_bounds_ = from.share_objective_bounds_;
    }
    if (cached_has_bits & 0x04000000u) {
      add_lin_max_cuts_ = from.add_lin_max_cuts_;
    }
    if (cached_has_bits & 0x08000000u) {
      add_lp_constraints_lazily_ = from.add_lp_constraints_lazily_;
    }
    if (cached_has_bits & 0x10000000u) {
      exploit_integer_lp_solution_ = from.exploit_integer_lp_solution_;
    }
    if (cached_has_bits & 0x20000000u) {
      exploit_all_lp_solution_ = from.exploit_all_lp_solution_;
    }
    if (cached_has_bits & 0x40000000u) {
      min_orthogonality_for_lp_constraints_ = from.min_orthogonality_for_lp_constraints_;
    }
    if (cached_has_bits & 0x80000000u) {
      max_integer_rounding_scaling_ = from.max_integer_rounding_scaling_;
    }
    _has_bits_[3] |= cached_has_bits;
  }
  cached_has_bits = from._has_bits_[4];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      max_consecutive_inactive_count_ = from.max_consecutive_inactive_count_;
    }
    if (cached_has_bits & 0x00000002u) {
      pseudo_cost_reliability_threshold_ = from.pseudo_cost_reliability_threshold_;
    }
    if (cached_has_bits & 0x00000004u) {
      mip_max_bound_ = from.mip_max_bound_;
    }
    if (cached_has_bits & 0x00000008u) {
      new_constraints_batch_size_ = from.new_constraints_batch_size_;
    }
    if (cached_has_bits & 0x00000010u) {
      mip_max_activity_exponent_ = from.mip_max_activity_exponent_;
    }
    if (cached_has_bits & 0x00000020u) {
      mip_var_scaling_ = from.mip_var_scaling_;
    }
    if (cached_has_bits & 0x00000040u) {
      mip_wanted_precision_ = from.mip_wanted_precision_;
    }
    if (cached_has_bits & 0x00000080u) {
      mip_check_precision_ = from.mip_check_precision_;
    }
    _has_bits_[4] |= cached_has_bits;
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      share_level_zero_bounds_ = from.share_level_zero_bounds_;
    }
    if (cached_has_bits & 0x00000200u) {
      use_rins_lns_ = from.use_rins_lns_;
    }
    if (cached_has_bits & 0x00000400u) {
      use_feasibility_pump_ = from.use_feasibility_pump_;
    }
    if (cached_has_bits & 0x00000800u) {
      use_optional_variables_ = from.use_optional_variables_;
    }
    if (cached_has_bits & 0x00001000u) {
      interleave_batch_size_ = from.interleave_batch_size_;
    }
    if (cached_has_bits & 0x00002000u) {
      max_presolve_iterations_ = from.max_presolve_iterations_;
    }
    if (cached_has_bits & 0x00004000u) {
      use_exact_lp_reason_ = from.use_exact_lp_reason_;
    }
    if (cached_has_bits & 0x00008000u) {
      catch_sigint_signal_ = from.catch_sigint_signal_;
    }
    _has_bits_[4] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00ff0000u) {
    if (cached_has_bits & 0x00010000u) {
      use_implied_bounds_ = from.use_implied_bounds_;
    }
    if (cached_has_bits & 0x00020000u) {
      convert_intervals_ = from.convert_intervals_;
    }
    if (cached_has_bits & 0x00040000u) {
      merge_no_overlap_work_limit_ = from.merge_no_overlap_work_limit_;
    }
    if (cached_has_bits & 0x00080000u) {
      add_cg_cuts_ = from.add_cg_cuts_;
    }
    if (cached_has_bits & 0x00100000u) {
      add_mir_cuts_ = from.add_mir_cuts_;
    }
    if (cached_has_bits & 0x00200000u) {
      add_zero_half_cuts_ = from.add_zero_half_cuts_;
    }
    if (cached_has_bits & 0x00400000u) {
      add_clique_cuts_ = from.add_clique_cuts_;
    }
    if (cached_has_bits & 0x00800000u) {
      presolve_substitution_level_ = from.presolve_substitution_level_;
    }
    _has_bits_[4] |= cached_has_bits;
  }
  if (cached_has_bits & 0xff000000u) {
    if (cached_has_bits & 0x01000000u) {
      merge_at_most_one_work_limit_ = from.merge_at_most_one_work_limit_;
    }
    if (cached_has_bits & 0x02000000u) {
      max_all_diff_cut_size_ = from.max_all_diff_cut_size_;
    }
    if (cached_has_bits & 0x04000000u) {
      hint_conflict_limit_ = from.hint_conflict_limit_;
    }
    if (cached_has_bits & 0x08000000u) {
      cut_max_active_count_value_ = from.cut_max_active_count_value_;
    }
    if (cached_has_bits & 0x10000000u) {
      max_cut_rounds_at_level_zero_ = from.max_cut_rounds_at_level_zero_;
    }
    if (cached_has_bits & 0x20000000u) {
      cut_cleanup_target_ = from.cut_cleanup_target_;
    }
    if (cached_has_bits & 0x40000000u) {
      cut_active_count_decay_ = from.cut_active_count_decay_;
    }
    if (cached_has_bits & 0x80000000u) {
      absolute_gap_limit_ = from.absolute_gap_limit_;
    }
    _has_bits_[4] |= cached_has_bits;
  }
  cached_has_bits = from._has_bits_[5];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      fp_rounding_ = from.fp_rounding_;
    }
    if (cached_has_bits & 0x00000002u) {
      polarity_rephase_increment_ = from.polarity_rephase_increment_;
    }
    if (cached_has_bits & 0x00000004u) {
      mip_automatically_scale_variables_ = from.mip_automatically_scale_variables_;
    }
    if (cached_has_bits & 0x00000008u) {
      mip_compute_true_objective_bound_ = from.mip_compute_true_objective_bound_;
    }
    if (cached_has_bits & 0x00000010u) {
      symmetry_level_ = from.symmetry_level_;
    }
    if (cached_has_bits & 0x00000020u) {
      clause_cleanup_ratio_ = from.clause_cleanup_ratio_;
    }
    if (cached_has_bits & 0x00000040u) {
      max_domain_size_when_encoding_eq_neq_constraints_ = from.max_domain_size_when_encoding_eq_neq_constraints_;
    }
    if (cached_has_bits & 0x00000080u) {
      solution_pool_size_ = from.solution_pool_size_;
    }
    _has_bits_[5] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    _internal_set_mip_max_valid_magnitude(from._internal_mip_max_valid_magnitude());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}
 
void SatParameters::CopyFrom(const SatParameters& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.sat.SatParameters)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}
 
bool SatParameters::IsInitialized() const {
  return true;
}
 
void SatParameters::InternalSwap(SatParameters* other) {
  using std::swap;
  auto* lhs_arena = GetArenaForAllocation();
  auto* rhs_arena = other->GetArenaForAllocation();
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(_has_bits_[1], other->_has_bits_[1]);
  swap(_has_bits_[2], other->_has_bits_[2]);
  swap(_has_bits_[3], other->_has_bits_[3]);
  swap(_has_bits_[4], other->_has_bits_[4]);
  swap(_has_bits_[5], other->_has_bits_[5]);
  restart_algorithms_.InternalSwap(&other->restart_algorithms_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      nullptr,
      &default_restart_algorithms_, lhs_arena,
      &other->default_restart_algorithms_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &name_, lhs_arena,
      &other->name_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &log_prefix_, lhs_arena,
      &other->log_prefix_, rhs_arena
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SatParameters, debug_crash_on_bad_hint_)
      + sizeof(SatParameters::debug_crash_on_bad_hint_)
      - PROTOBUF_FIELD_OFFSET(SatParameters, preferred_variable_order_)>(
          reinterpret_cast<char*>(&preferred_variable_order_),
          reinterpret_cast<char*>(&other->preferred_variable_order_));
  swap(cut_level_, other->cut_level_);
  swap(initial_polarity_, other->initial_polarity_);
  swap(minimization_algorithm_, other->minimization_algorithm_);
  swap(variable_activity_decay_, other->variable_activity_decay_);
  swap(max_variable_activity_value_, other->max_variable_activity_value_);
  swap(clause_activity_decay_, other->clause_activity_decay_);
  swap(clause_cleanup_period_, other->clause_cleanup_period_);
  swap(glucose_decay_increment_period_, other->glucose_decay_increment_period_);
  swap(max_clause_activity_value_, other->max_clause_activity_value_);
  swap(glucose_max_decay_, other->glucose_max_decay_);
  swap(glucose_decay_increment_, other->glucose_decay_increment_);
  swap(restart_period_, other->restart_period_);
  swap(random_seed_, other->random_seed_);
  swap(max_time_in_seconds_, other->max_time_in_seconds_);
  swap(max_number_of_conflicts_, other->max_number_of_conflicts_);
  swap(max_memory_in_mb_, other->max_memory_in_mb_);
  swap(binary_minimization_algorithm_, other->binary_minimization_algorithm_);
  swap(pb_cleanup_increment_, other->pb_cleanup_increment_);
  swap(pb_cleanup_ratio_, other->pb_cleanup_ratio_);
  swap(max_sat_stratification_, other->max_sat_stratification_);
  swap(presolve_bve_threshold_, other->presolve_bve_threshold_);
  swap(presolve_probing_deterministic_time_limit_, other->presolve_probing_deterministic_time_limit_);
  swap(presolve_bve_clause_weight_, other->presolve_bve_clause_weight_);
  swap(clause_cleanup_lbd_bound_, other->clause_cleanup_lbd_bound_);
  swap(restart_dl_average_ratio_, other->restart_dl_average_ratio_);
  swap(restart_running_window_size_, other->restart_running_window_size_);
  swap(blocking_restart_window_size_, other->blocking_restart_window_size_);
  swap(blocking_restart_multiplier_, other->blocking_restart_multiplier_);
  swap(max_deterministic_time_, other->max_deterministic_time_);
  swap(cp_model_presolve_, other->cp_model_presolve_);
  swap(cp_model_use_sat_presolve_, other->cp_model_use_sat_presolve_);
  swap(use_optimization_hints_, other->use_optimization_hints_);
  swap(minimize_core_, other->minimize_core_);
  swap(presolve_bva_threshold_, other->presolve_bva_threshold_);
  swap(restart_lbd_average_ratio_, other->restart_lbd_average_ratio_);
  swap(use_phase_saving_, other->use_phase_saving_);
  swap(subsumption_during_conflict_analysis_, other->subsumption_during_conflict_analysis_);
  swap(treat_binary_clauses_separately_, other->treat_binary_clauses_separately_);
  swap(log_subsolver_statistics_, other->log_subsolver_statistics_);
  swap(find_multiple_cores_, other->find_multiple_cores_);
  swap(cover_optimization_, other->cover_optimization_);
  swap(use_precedences_in_disjunctive_constraint_, other->use_precedences_in_disjunctive_constraint_);
  swap(use_disjunctive_constraint_in_cumulative_constraint_, other->use_disjunctive_constraint_in_cumulative_constraint_);
  swap(linearization_level_, other->linearization_level_);
  swap(max_num_cuts_, other->max_num_cuts_);
  swap(minimize_with_propagation_restart_period_, other->minimize_with_propagation_restart_period_);
  swap(minimize_with_propagation_num_decisions_, other->minimize_with_propagation_num_decisions_);
  swap(log_to_stdout_, other->log_to_stdout_);
  swap(count_assumption_levels_in_lbd_, other->count_assumption_levels_in_lbd_);
  swap(presolve_blocked_clause_, other->presolve_blocked_clause_);
  swap(presolve_use_bva_, other->presolve_use_bva_);
  swap(binary_search_num_conflicts_, other->binary_search_num_conflicts_);
  swap(boolean_encoding_level_, other->boolean_encoding_level_);
  swap(cp_model_probing_level_, other->cp_model_probing_level_);
  swap(exploit_objective_, other->exploit_objective_);
  swap(instantiate_all_variables_, other->instantiate_all_variables_);
  swap(auto_detect_greater_than_at_least_one_of_, other->auto_detect_greater_than_at_least_one_of_);
  swap(share_objective_bounds_, other->share_objective_bounds_);
  swap(add_lin_max_cuts_, other->add_lin_max_cuts_);
  swap(add_lp_constraints_lazily_, other->add_lp_constraints_lazily_);
  swap(exploit_integer_lp_solution_, other->exploit_integer_lp_solution_);
  swap(exploit_all_lp_solution_, other->exploit_all_lp_solution_);
  swap(min_orthogonality_for_lp_constraints_, other->min_orthogonality_for_lp_constraints_);
  swap(max_integer_rounding_scaling_, other->max_integer_rounding_scaling_);
  swap(max_consecutive_inactive_count_, other->max_consecutive_inactive_count_);
  swap(pseudo_cost_reliability_threshold_, other->pseudo_cost_reliability_threshold_);
  swap(mip_max_bound_, other->mip_max_bound_);
  swap(new_constraints_batch_size_, other->new_constraints_batch_size_);
  swap(mip_max_activity_exponent_, other->mip_max_activity_exponent_);
  swap(mip_var_scaling_, other->mip_var_scaling_);
  swap(mip_wanted_precision_, other->mip_wanted_precision_);
  swap(mip_check_precision_, other->mip_check_precision_);
  swap(share_level_zero_bounds_, other->share_level_zero_bounds_);
  swap(use_rins_lns_, other->use_rins_lns_);
  swap(use_feasibility_pump_, other->use_feasibility_pump_);
  swap(use_optional_variables_, other->use_optional_variables_);
  swap(interleave_batch_size_, other->interleave_batch_size_);
  swap(max_presolve_iterations_, other->max_presolve_iterations_);
  swap(use_exact_lp_reason_, other->use_exact_lp_reason_);
  swap(catch_sigint_signal_, other->catch_sigint_signal_);
  swap(use_implied_bounds_, other->use_implied_bounds_);
  swap(convert_intervals_, other->convert_intervals_);
  swap(merge_no_overlap_work_limit_, other->merge_no_overlap_work_limit_);
  swap(add_cg_cuts_, other->add_cg_cuts_);
  swap(add_mir_cuts_, other->add_mir_cuts_);
  swap(add_zero_half_cuts_, other->add_zero_half_cuts_);
  swap(add_clique_cuts_, other->add_clique_cuts_);
  swap(presolve_substitution_level_, other->presolve_substitution_level_);
  swap(merge_at_most_one_work_limit_, other->merge_at_most_one_work_limit_);
  swap(max_all_diff_cut_size_, other->max_all_diff_cut_size_);
  swap(hint_conflict_limit_, other->hint_conflict_limit_);
  swap(cut_max_active_count_value_, other->cut_max_active_count_value_);
  swap(max_cut_rounds_at_level_zero_, other->max_cut_rounds_at_level_zero_);
  swap(cut_cleanup_target_, other->cut_cleanup_target_);
  swap(cut_active_count_decay_, other->cut_active_count_decay_);
  swap(absolute_gap_limit_, other->absolute_gap_limit_);
  swap(fp_rounding_, other->fp_rounding_);
  swap(polarity_rephase_increment_, other->polarity_rephase_increment_);
  swap(mip_automatically_scale_variables_, other->mip_automatically_scale_variables_);
  swap(mip_compute_true_objective_bound_, other->mip_compute_true_objective_bound_);
  swap(symmetry_level_, other->symmetry_level_);
  swap(clause_cleanup_ratio_, other->clause_cleanup_ratio_);
  swap(max_domain_size_when_encoding_eq_neq_constraints_, other->max_domain_size_when_encoding_eq_neq_constraints_);
  swap(solution_pool_size_, other->solution_pool_size_);
  swap(mip_max_valid_magnitude_, other->mip_max_valid_magnitude_);
}
 
::PROTOBUF_NAMESPACE_ID::Metadata SatParameters::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto_getter, &descriptor_table_ortools_2fsat_2fsat_5fparameters_2eproto_once,
      file_level_metadata_ortools_2fsat_2fsat_5fparameters_2eproto[0]);
}
 
// @@protoc_insertion_point(namespace_scope)
}  // namespace sat
}  // namespace operations_research
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::operations_research::sat::SatParameters* Arena::CreateMaybeMessage< ::operations_research::sat::SatParameters >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::sat::SatParameters >(arena);
}
PROTOBUF_NAMESPACE_CLOSE
 
// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>