parameters.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: ortools/math_opt/parameters.proto
// Protobuf C++ Version: 6.33.1
 
#ifndef ortools_2fmath_5fopt_2fparameters_2eproto_2epb_2eh
#define ortools_2fmath_5fopt_2fparameters_2eproto_2epb_2eh
 
#include <limits>
#include <string>
#include <type_traits>
#include <utility>
 
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 6033001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/message.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "google/protobuf/duration.pb.h"
#include "ortools/pdlp/solvers.pb.h"
#include "ortools/glop/parameters.pb.h"
#include "ortools/math_opt/solvers/glpk.pb.h"
#include "ortools/math_opt/solvers/gscip/gscip.pb.h"
#include "ortools/math_opt/solvers/gurobi.pb.h"
#include "ortools/math_opt/solvers/highs.pb.h"
#include "ortools/math_opt/solvers/osqp.pb.h"
#include "ortools/math_opt/solvers/xpress.pb.h"
#include "ortools/sat/sat_parameters.pb.h"
// @@protoc_insertion_point(includes)
 
// Must be included last.
#include "google/protobuf/port_def.inc"
 
#define PROTOBUF_INTERNAL_EXPORT_ortools_2fmath_5fopt_2fparameters_2eproto OR_PROTO_DLL
 
namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google
 
// Internal implementation detail -- do not use these members.
struct OR_PROTO_DLL TableStruct_ortools_2fmath_5fopt_2fparameters_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
OR_PROTO_DLL extern const ::google::protobuf::internal::DescriptorTable descriptor_table_ortools_2fmath_5fopt_2fparameters_2eproto;
}  // extern "C"
namespace operations_research {
namespace math_opt {
enum EmphasisProto : int;
OR_PROTO_DLL extern const uint32_t EmphasisProto_internal_data_[];
enum LPAlgorithmProto : int;
OR_PROTO_DLL extern const uint32_t LPAlgorithmProto_internal_data_[];
enum SolverTypeProto : int;
OR_PROTO_DLL extern const uint32_t SolverTypeProto_internal_data_[];
class SolveParametersProto;
struct SolveParametersProtoDefaultTypeInternal;
OR_PROTO_DLL extern SolveParametersProtoDefaultTypeInternal _SolveParametersProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolveParametersProto_class_data_;
class SolverInitializerProto;
struct SolverInitializerProtoDefaultTypeInternal;
OR_PROTO_DLL extern SolverInitializerProtoDefaultTypeInternal _SolverInitializerProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolverInitializerProto_class_data_;
class StrictnessProto;
struct StrictnessProtoDefaultTypeInternal;
OR_PROTO_DLL extern StrictnessProtoDefaultTypeInternal _StrictnessProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull StrictnessProto_class_data_;
}  // namespace math_opt
}  // namespace operations_research
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::operations_research::math_opt::EmphasisProto_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::math_opt::EmphasisProto>;
template <>
internal::EnumTraitsT<::operations_research::math_opt::LPAlgorithmProto_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::math_opt::LPAlgorithmProto>;
template <>
internal::EnumTraitsT<::operations_research::math_opt::SolverTypeProto_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::math_opt::SolverTypeProto>;
}  // namespace protobuf
}  // namespace google
 
namespace operations_research {
namespace math_opt {
enum SolverTypeProto : int {
  SOLVER_TYPE_UNSPECIFIED = 0,
  SOLVER_TYPE_GSCIP = 1,
  SOLVER_TYPE_GUROBI = 2,
  SOLVER_TYPE_GLOP = 3,
  SOLVER_TYPE_CP_SAT = 4,
  SOLVER_TYPE_PDLP = 5,
  SOLVER_TYPE_GLPK = 6,
  SOLVER_TYPE_OSQP = 7,
  SOLVER_TYPE_ECOS = 8,
  SOLVER_TYPE_SCS = 9,
  SOLVER_TYPE_HIGHS = 10,
  SOLVER_TYPE_SANTORINI = 11,
  SOLVER_TYPE_XPRESS = 13,
  SolverTypeProto_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  SolverTypeProto_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};
 
OR_PROTO_DLL extern const uint32_t SolverTypeProto_internal_data_[];
inline constexpr SolverTypeProto SolverTypeProto_MIN =
    static_cast<SolverTypeProto>(0);
inline constexpr SolverTypeProto SolverTypeProto_MAX =
    static_cast<SolverTypeProto>(13);
inline bool SolverTypeProto_IsValid(int value) {
  return 0 <= value && value <= 13 && ((12287u >> value) & 1) != 0;
}
inline constexpr int SolverTypeProto_ARRAYSIZE = 13 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SolverTypeProto_descriptor();
template <typename T>
const ::std::string& SolverTypeProto_Name(T value) {
  static_assert(::std::is_same<T, SolverTypeProto>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to SolverTypeProto_Name().");
  return SolverTypeProto_Name(static_cast<SolverTypeProto>(value));
}
template <>
inline const ::std::string& SolverTypeProto_Name(SolverTypeProto value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SolverTypeProto_descriptor, 0, 13>(
      static_cast<int>(value));
}
inline bool SolverTypeProto_Parse(
    ::absl::string_view name, SolverTypeProto* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<SolverTypeProto>(SolverTypeProto_descriptor(), name,
                                           value);
}
enum LPAlgorithmProto : int {
  LP_ALGORITHM_UNSPECIFIED = 0,
  LP_ALGORITHM_PRIMAL_SIMPLEX = 1,
  LP_ALGORITHM_DUAL_SIMPLEX = 2,
  LP_ALGORITHM_BARRIER = 3,
  LP_ALGORITHM_FIRST_ORDER = 4,
  LPAlgorithmProto_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  LPAlgorithmProto_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};
 
OR_PROTO_DLL extern const uint32_t LPAlgorithmProto_internal_data_[];
inline constexpr LPAlgorithmProto LPAlgorithmProto_MIN =
    static_cast<LPAlgorithmProto>(0);
inline constexpr LPAlgorithmProto LPAlgorithmProto_MAX =
    static_cast<LPAlgorithmProto>(4);
inline bool LPAlgorithmProto_IsValid(int value) {
  return 0 <= value && value <= 4;
}
inline constexpr int LPAlgorithmProto_ARRAYSIZE = 4 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL LPAlgorithmProto_descriptor();
template <typename T>
const ::std::string& LPAlgorithmProto_Name(T value) {
  static_assert(::std::is_same<T, LPAlgorithmProto>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to LPAlgorithmProto_Name().");
  return LPAlgorithmProto_Name(static_cast<LPAlgorithmProto>(value));
}
template <>
inline const ::std::string& LPAlgorithmProto_Name(LPAlgorithmProto value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LPAlgorithmProto_descriptor, 0, 4>(
      static_cast<int>(value));
}
inline bool LPAlgorithmProto_Parse(
    ::absl::string_view name, LPAlgorithmProto* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<LPAlgorithmProto>(LPAlgorithmProto_descriptor(), name,
                                           value);
}
enum EmphasisProto : int {
  EMPHASIS_UNSPECIFIED = 0,
  EMPHASIS_OFF = 1,
  EMPHASIS_LOW = 2,
  EMPHASIS_MEDIUM = 3,
  EMPHASIS_HIGH = 4,
  EMPHASIS_VERY_HIGH = 5,
  EmphasisProto_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  EmphasisProto_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};
 
OR_PROTO_DLL extern const uint32_t EmphasisProto_internal_data_[];
inline constexpr EmphasisProto EmphasisProto_MIN =
    static_cast<EmphasisProto>(0);
inline constexpr EmphasisProto EmphasisProto_MAX =
    static_cast<EmphasisProto>(5);
inline bool EmphasisProto_IsValid(int value) {
  return 0 <= value && value <= 5;
}
inline constexpr int EmphasisProto_ARRAYSIZE = 5 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL EmphasisProto_descriptor();
template <typename T>
const ::std::string& EmphasisProto_Name(T value) {
  static_assert(::std::is_same<T, EmphasisProto>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to EmphasisProto_Name().");
  return EmphasisProto_Name(static_cast<EmphasisProto>(value));
}
template <>
inline const ::std::string& EmphasisProto_Name(EmphasisProto value) {
  return ::google::protobuf::internal::NameOfDenseEnum<EmphasisProto_descriptor, 0, 5>(
      static_cast<int>(value));
}
inline bool EmphasisProto_Parse(
    ::absl::string_view name, EmphasisProto* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<EmphasisProto>(EmphasisProto_descriptor(), name,
                                           value);
}
 
// ===================================================================
 
 
// -------------------------------------------------------------------
 
class OR_PROTO_DLL StrictnessProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.StrictnessProto) */ {
 public:
  inline StrictnessProto() : StrictnessProto(nullptr) {}
  ~StrictnessProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(StrictnessProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(StrictnessProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR StrictnessProto(::google::protobuf::internal::ConstantInitialized);
 
  inline StrictnessProto(const StrictnessProto& from) : StrictnessProto(nullptr, from) {}
  inline StrictnessProto(StrictnessProto&& from) noexcept
      : StrictnessProto(nullptr, ::std::move(from)) {}
  inline StrictnessProto& operator=(const StrictnessProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline StrictnessProto& operator=(StrictnessProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }
 
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const StrictnessProto& default_instance() {
    return *reinterpret_cast<const StrictnessProto*>(
        &_StrictnessProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(StrictnessProto& a, StrictnessProto& b) { a.Swap(&b); }
  inline void Swap(StrictnessProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StrictnessProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  StrictnessProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<StrictnessProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const StrictnessProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const StrictnessProto& from) { StrictnessProto::MergeImpl(*this, from); }
 
  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);
 
  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
 
  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(StrictnessProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "operations_research.math_opt.StrictnessProto"; }
 
  explicit StrictnessProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  StrictnessProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const StrictnessProto& from);
  StrictnessProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, StrictnessProto&& from) noexcept
      : StrictnessProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();
 
 public:
  static constexpr auto InternalGenerateClassData_();
 
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
  enum : int {
    kBadParameterFieldNumber = 1,
  };
  // bool bad_parameter = 1;
  void clear_bad_parameter() ;
  bool bad_parameter() const;
  void set_bad_parameter(bool value);
 
  private:
  bool _internal_bad_parameter() const;
  void _internal_set_bad_parameter(bool value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.StrictnessProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 1,
                                   0, 0,
                                   2>
      _table_;
 
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const StrictnessProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    bool bad_parameter_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fparameters_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull StrictnessProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL SolverInitializerProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.SolverInitializerProto) */ {
 public:
  inline SolverInitializerProto() : SolverInitializerProto(nullptr) {}
  ~SolverInitializerProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SolverInitializerProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SolverInitializerProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR SolverInitializerProto(::google::protobuf::internal::ConstantInitialized);
 
  inline SolverInitializerProto(const SolverInitializerProto& from) : SolverInitializerProto(nullptr, from) {}
  inline SolverInitializerProto(SolverInitializerProto&& from) noexcept
      : SolverInitializerProto(nullptr, ::std::move(from)) {}
  inline SolverInitializerProto& operator=(const SolverInitializerProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SolverInitializerProto& operator=(SolverInitializerProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }
 
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SolverInitializerProto& default_instance() {
    return *reinterpret_cast<const SolverInitializerProto*>(
        &_SolverInitializerProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(SolverInitializerProto& a, SolverInitializerProto& b) { a.Swap(&b); }
  inline void Swap(SolverInitializerProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SolverInitializerProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SolverInitializerProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SolverInitializerProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SolverInitializerProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SolverInitializerProto& from) { SolverInitializerProto::MergeImpl(*this, from); }
 
  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);
 
  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
 
  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SolverInitializerProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "operations_research.math_opt.SolverInitializerProto"; }
 
  explicit SolverInitializerProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SolverInitializerProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SolverInitializerProto& from);
  SolverInitializerProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SolverInitializerProto&& from) noexcept
      : SolverInitializerProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();
 
 public:
  static constexpr auto InternalGenerateClassData_();
 
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
  enum : int {
    kGurobiFieldNumber = 1,
    kXpressFieldNumber = 3,
  };
  // .operations_research.math_opt.GurobiInitializerProto gurobi = 1;
  bool has_gurobi() const;
  void clear_gurobi() ;
  const ::operations_research::math_opt::GurobiInitializerProto& gurobi() const;
  [[nodiscard]] ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE release_gurobi();
  ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NONNULL mutable_gurobi();
  void set_allocated_gurobi(::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_gurobi(::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE unsafe_arena_release_gurobi();
 
  private:
  const ::operations_research::math_opt::GurobiInitializerProto& _internal_gurobi() const;
  ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NONNULL _internal_mutable_gurobi();
 
  public:
  // .operations_research.math_opt.XpressInitializerProto xpress = 3;
  bool has_xpress() const;
  void clear_xpress() ;
  const ::operations_research::math_opt::XpressInitializerProto& xpress() const;
  [[nodiscard]] ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE release_xpress();
  ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NONNULL mutable_xpress();
  void set_allocated_xpress(::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_xpress(::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE unsafe_arena_release_xpress();
 
  private:
  const ::operations_research::math_opt::XpressInitializerProto& _internal_xpress() const;
  ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NONNULL _internal_mutable_xpress();
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.SolverInitializerProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 2,
                                   2, 0,
                                   2>
      _table_;
 
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SolverInitializerProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE gurobi_;
    ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE xpress_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fparameters_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolverInitializerProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL SolveParametersProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.SolveParametersProto) */ {
 public:
  inline SolveParametersProto() : SolveParametersProto(nullptr) {}
  ~SolveParametersProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SolveParametersProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SolveParametersProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR SolveParametersProto(::google::protobuf::internal::ConstantInitialized);
 
  inline SolveParametersProto(const SolveParametersProto& from) : SolveParametersProto(nullptr, from) {}
  inline SolveParametersProto(SolveParametersProto&& from) noexcept
      : SolveParametersProto(nullptr, ::std::move(from)) {}
  inline SolveParametersProto& operator=(const SolveParametersProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SolveParametersProto& operator=(SolveParametersProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance);
  }
  inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields()
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>();
  }
 
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() {
    return GetDescriptor();
  }
  static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const SolveParametersProto& default_instance() {
    return *reinterpret_cast<const SolveParametersProto*>(
        &_SolveParametersProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(SolveParametersProto& a, SolveParametersProto& b) { a.Swap(&b); }
  inline void Swap(SolveParametersProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SolveParametersProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SolveParametersProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SolveParametersProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SolveParametersProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SolveParametersProto& from) { SolveParametersProto::MergeImpl(*this, from); }
 
  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);
 
  public:
  bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);
 
  public:
  ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  ::size_t ByteSizeLong() const final;
  ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  int GetCachedSize() const { return _impl_._cached_size_.Get(); }
 
  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SolveParametersProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "operations_research.math_opt.SolveParametersProto"; }
 
  explicit SolveParametersProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SolveParametersProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SolveParametersProto& from);
  SolveParametersProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SolveParametersProto&& from) noexcept
      : SolveParametersProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();
 
 public:
  static constexpr auto InternalGenerateClassData_();
 
  ::google::protobuf::Metadata GetMetadata() const;
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
  enum : int {
    kTimeLimitFieldNumber = 1,
    kGscipFieldNumber = 12,
    kGurobiFieldNumber = 13,
    kGlopFieldNumber = 14,
    kCpSatFieldNumber = 15,
    kPdlpFieldNumber = 16,
    kOsqpFieldNumber = 19,
    kGlpkFieldNumber = 26,
    kHighsFieldNumber = 27,
    kXpressFieldNumber = 28,
    kIterationLimitFieldNumber = 2,
    kEnableOutputFieldNumber = 3,
    kThreadsFieldNumber = 4,
    kRandomSeedFieldNumber = 5,
    kLpAlgorithmFieldNumber = 6,
    kPresolveFieldNumber = 7,
    kCutsFieldNumber = 8,
    kHeuristicsFieldNumber = 9,
    kScalingFieldNumber = 10,
    kRelativeGapToleranceFieldNumber = 17,
    kAbsoluteGapToleranceFieldNumber = 18,
    kCutoffLimitFieldNumber = 20,
    kObjectiveLimitFieldNumber = 21,
    kBestBoundLimitFieldNumber = 22,
    kNodeLimitFieldNumber = 24,
    kSolutionLimitFieldNumber = 23,
    kSolutionPoolSizeFieldNumber = 25,
  };
  // .google.protobuf.Duration time_limit = 1;
  bool has_time_limit() const;
  void clear_time_limit() ;
  const ::google::protobuf::Duration& time_limit() const;
  [[nodiscard]] ::google::protobuf::Duration* PROTOBUF_NULLABLE release_time_limit();
  ::google::protobuf::Duration* PROTOBUF_NONNULL mutable_time_limit();
  void set_allocated_time_limit(::google::protobuf::Duration* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_time_limit(::google::protobuf::Duration* PROTOBUF_NULLABLE value);
  ::google::protobuf::Duration* PROTOBUF_NULLABLE unsafe_arena_release_time_limit();
 
  private:
  const ::google::protobuf::Duration& _internal_time_limit() const;
  ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_time_limit();
 
  public:
  // .operations_research.GScipParameters gscip = 12;
  bool has_gscip() const;
  void clear_gscip() ;
  const ::operations_research::GScipParameters& gscip() const;
  [[nodiscard]] ::operations_research::GScipParameters* PROTOBUF_NULLABLE release_gscip();
  ::operations_research::GScipParameters* PROTOBUF_NONNULL mutable_gscip();
  void set_allocated_gscip(::operations_research::GScipParameters* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_gscip(::operations_research::GScipParameters* PROTOBUF_NULLABLE value);
  ::operations_research::GScipParameters* PROTOBUF_NULLABLE unsafe_arena_release_gscip();
 
  private:
  const ::operations_research::GScipParameters& _internal_gscip() const;
  ::operations_research::GScipParameters* PROTOBUF_NONNULL _internal_mutable_gscip();
 
  public:
  // .operations_research.math_opt.GurobiParametersProto gurobi = 13;
  bool has_gurobi() const;
  void clear_gurobi() ;
  const ::operations_research::math_opt::GurobiParametersProto& gurobi() const;
  [[nodiscard]] ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE release_gurobi();
  ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NONNULL mutable_gurobi();
  void set_allocated_gurobi(::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_gurobi(::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE unsafe_arena_release_gurobi();
 
  private:
  const ::operations_research::math_opt::GurobiParametersProto& _internal_gurobi() const;
  ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NONNULL _internal_mutable_gurobi();
 
  public:
  // .operations_research.glop.GlopParameters glop = 14;
  bool has_glop() const;
  void clear_glop() ;
  const ::operations_research::glop::GlopParameters& glop() const;
  [[nodiscard]] ::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE release_glop();
  ::operations_research::glop::GlopParameters* PROTOBUF_NONNULL mutable_glop();
  void set_allocated_glop(::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_glop(::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE value);
  ::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE unsafe_arena_release_glop();
 
  private:
  const ::operations_research::glop::GlopParameters& _internal_glop() const;
  ::operations_research::glop::GlopParameters* PROTOBUF_NONNULL _internal_mutable_glop();
 
  public:
  // .operations_research.sat.SatParameters cp_sat = 15;
  bool has_cp_sat() const;
  void clear_cp_sat() ;
  const ::operations_research::sat::SatParameters& cp_sat() const;
  [[nodiscard]] ::operations_research::sat::SatParameters* PROTOBUF_NULLABLE release_cp_sat();
  ::operations_research::sat::SatParameters* PROTOBUF_NONNULL mutable_cp_sat();
  void set_allocated_cp_sat(::operations_research::sat::SatParameters* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_cp_sat(::operations_research::sat::SatParameters* PROTOBUF_NULLABLE value);
  ::operations_research::sat::SatParameters* PROTOBUF_NULLABLE unsafe_arena_release_cp_sat();
 
  private:
  const ::operations_research::sat::SatParameters& _internal_cp_sat() const;
  ::operations_research::sat::SatParameters* PROTOBUF_NONNULL _internal_mutable_cp_sat();
 
  public:
  // .operations_research.pdlp.PrimalDualHybridGradientParams pdlp = 16;
  bool has_pdlp() const;
  void clear_pdlp() ;
  const ::operations_research::pdlp::PrimalDualHybridGradientParams& pdlp() const;
  [[nodiscard]] ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE release_pdlp();
  ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NONNULL mutable_pdlp();
  void set_allocated_pdlp(::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_pdlp(::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE value);
  ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE unsafe_arena_release_pdlp();
 
  private:
  const ::operations_research::pdlp::PrimalDualHybridGradientParams& _internal_pdlp() const;
  ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NONNULL _internal_mutable_pdlp();
 
  public:
  // .operations_research.math_opt.OsqpSettingsProto osqp = 19;
  bool has_osqp() const;
  void clear_osqp() ;
  const ::operations_research::math_opt::OsqpSettingsProto& osqp() const;
  [[nodiscard]] ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE release_osqp();
  ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NONNULL mutable_osqp();
  void set_allocated_osqp(::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_osqp(::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE unsafe_arena_release_osqp();
 
  private:
  const ::operations_research::math_opt::OsqpSettingsProto& _internal_osqp() const;
  ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NONNULL _internal_mutable_osqp();
 
  public:
  // .operations_research.math_opt.GlpkParametersProto glpk = 26;
  bool has_glpk() const;
  void clear_glpk() ;
  const ::operations_research::math_opt::GlpkParametersProto& glpk() const;
  [[nodiscard]] ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE release_glpk();
  ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NONNULL mutable_glpk();
  void set_allocated_glpk(::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_glpk(::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE unsafe_arena_release_glpk();
 
  private:
  const ::operations_research::math_opt::GlpkParametersProto& _internal_glpk() const;
  ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NONNULL _internal_mutable_glpk();
 
  public:
  // .operations_research.math_opt.HighsOptionsProto highs = 27;
  bool has_highs() const;
  void clear_highs() ;
  const ::operations_research::math_opt::HighsOptionsProto& highs() const;
  [[nodiscard]] ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE release_highs();
  ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NONNULL mutable_highs();
  void set_allocated_highs(::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_highs(::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE unsafe_arena_release_highs();
 
  private:
  const ::operations_research::math_opt::HighsOptionsProto& _internal_highs() const;
  ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NONNULL _internal_mutable_highs();
 
  public:
  // .operations_research.math_opt.XpressParametersProto xpress = 28;
  bool has_xpress() const;
  void clear_xpress() ;
  const ::operations_research::math_opt::XpressParametersProto& xpress() const;
  [[nodiscard]] ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE release_xpress();
  ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NONNULL mutable_xpress();
  void set_allocated_xpress(::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_xpress(::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE unsafe_arena_release_xpress();
 
  private:
  const ::operations_research::math_opt::XpressParametersProto& _internal_xpress() const;
  ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NONNULL _internal_mutable_xpress();
 
  public:
  // optional int64 iteration_limit = 2;
  bool has_iteration_limit() const;
  void clear_iteration_limit() ;
  ::int64_t iteration_limit() const;
  void set_iteration_limit(::int64_t value);
 
  private:
  ::int64_t _internal_iteration_limit() const;
  void _internal_set_iteration_limit(::int64_t value);
 
  public:
  // bool enable_output = 3;
  void clear_enable_output() ;
  bool enable_output() const;
  void set_enable_output(bool value);
 
  private:
  bool _internal_enable_output() const;
  void _internal_set_enable_output(bool value);
 
  public:
  // optional int32 threads = 4;
  bool has_threads() const;
  void clear_threads() ;
  ::int32_t threads() const;
  void set_threads(::int32_t value);
 
  private:
  ::int32_t _internal_threads() const;
  void _internal_set_threads(::int32_t value);
 
  public:
  // optional int32 random_seed = 5;
  bool has_random_seed() const;
  void clear_random_seed() ;
  ::int32_t random_seed() const;
  void set_random_seed(::int32_t value);
 
  private:
  ::int32_t _internal_random_seed() const;
  void _internal_set_random_seed(::int32_t value);
 
  public:
  // .operations_research.math_opt.LPAlgorithmProto lp_algorithm = 6;
  void clear_lp_algorithm() ;
  ::operations_research::math_opt::LPAlgorithmProto lp_algorithm() const;
  void set_lp_algorithm(::operations_research::math_opt::LPAlgorithmProto value);
 
  private:
  ::operations_research::math_opt::LPAlgorithmProto _internal_lp_algorithm() const;
  void _internal_set_lp_algorithm(::operations_research::math_opt::LPAlgorithmProto value);
 
  public:
  // .operations_research.math_opt.EmphasisProto presolve = 7;
  void clear_presolve() ;
  ::operations_research::math_opt::EmphasisProto presolve() const;
  void set_presolve(::operations_research::math_opt::EmphasisProto value);
 
  private:
  ::operations_research::math_opt::EmphasisProto _internal_presolve() const;
  void _internal_set_presolve(::operations_research::math_opt::EmphasisProto value);
 
  public:
  // .operations_research.math_opt.EmphasisProto cuts = 8;
  void clear_cuts() ;
  ::operations_research::math_opt::EmphasisProto cuts() const;
  void set_cuts(::operations_research::math_opt::EmphasisProto value);
 
  private:
  ::operations_research::math_opt::EmphasisProto _internal_cuts() const;
  void _internal_set_cuts(::operations_research::math_opt::EmphasisProto value);
 
  public:
  // .operations_research.math_opt.EmphasisProto heuristics = 9;
  void clear_heuristics() ;
  ::operations_research::math_opt::EmphasisProto heuristics() const;
  void set_heuristics(::operations_research::math_opt::EmphasisProto value);
 
  private:
  ::operations_research::math_opt::EmphasisProto _internal_heuristics() const;
  void _internal_set_heuristics(::operations_research::math_opt::EmphasisProto value);
 
  public:
  // .operations_research.math_opt.EmphasisProto scaling = 10;
  void clear_scaling() ;
  ::operations_research::math_opt::EmphasisProto scaling() const;
  void set_scaling(::operations_research::math_opt::EmphasisProto value);
 
  private:
  ::operations_research::math_opt::EmphasisProto _internal_scaling() const;
  void _internal_set_scaling(::operations_research::math_opt::EmphasisProto value);
 
  public:
  // optional double relative_gap_tolerance = 17;
  bool has_relative_gap_tolerance() const;
  void clear_relative_gap_tolerance() ;
  double relative_gap_tolerance() const;
  void set_relative_gap_tolerance(double value);
 
  private:
  double _internal_relative_gap_tolerance() const;
  void _internal_set_relative_gap_tolerance(double value);
 
  public:
  // optional double absolute_gap_tolerance = 18;
  bool has_absolute_gap_tolerance() const;
  void clear_absolute_gap_tolerance() ;
  double absolute_gap_tolerance() const;
  void set_absolute_gap_tolerance(double value);
 
  private:
  double _internal_absolute_gap_tolerance() const;
  void _internal_set_absolute_gap_tolerance(double value);
 
  public:
  // optional double cutoff_limit = 20;
  bool has_cutoff_limit() const;
  void clear_cutoff_limit() ;
  double cutoff_limit() const;
  void set_cutoff_limit(double value);
 
  private:
  double _internal_cutoff_limit() const;
  void _internal_set_cutoff_limit(double value);
 
  public:
  // optional double objective_limit = 21;
  bool has_objective_limit() const;
  void clear_objective_limit() ;
  double objective_limit() const;
  void set_objective_limit(double value);
 
  private:
  double _internal_objective_limit() const;
  void _internal_set_objective_limit(double value);
 
  public:
  // optional double best_bound_limit = 22;
  bool has_best_bound_limit() const;
  void clear_best_bound_limit() ;
  double best_bound_limit() const;
  void set_best_bound_limit(double value);
 
  private:
  double _internal_best_bound_limit() const;
  void _internal_set_best_bound_limit(double value);
 
  public:
  // optional int64 node_limit = 24;
  bool has_node_limit() const;
  void clear_node_limit() ;
  ::int64_t node_limit() const;
  void set_node_limit(::int64_t value);
 
  private:
  ::int64_t _internal_node_limit() const;
  void _internal_set_node_limit(::int64_t value);
 
  public:
  // optional int32 solution_limit = 23;
  bool has_solution_limit() const;
  void clear_solution_limit() ;
  ::int32_t solution_limit() const;
  void set_solution_limit(::int32_t value);
 
  private:
  ::int32_t _internal_solution_limit() const;
  void _internal_set_solution_limit(::int32_t value);
 
  public:
  // optional int32 solution_pool_size = 25;
  bool has_solution_pool_size() const;
  void clear_solution_pool_size() ;
  ::int32_t solution_pool_size() const;
  void set_solution_pool_size(::int32_t value);
 
  private:
  ::int32_t _internal_solution_pool_size() const;
  void _internal_set_solution_pool_size(::int32_t value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.SolveParametersProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<5, 27,
                                   10, 0,
                                   2>
      _table_;
 
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SolveParametersProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::Duration* PROTOBUF_NULLABLE time_limit_;
    ::operations_research::GScipParameters* PROTOBUF_NULLABLE gscip_;
    ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE gurobi_;
    ::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE glop_;
    ::operations_research::sat::SatParameters* PROTOBUF_NULLABLE cp_sat_;
    ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE pdlp_;
    ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE osqp_;
    ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE glpk_;
    ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE highs_;
    ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE xpress_;
    ::int64_t iteration_limit_;
    bool enable_output_;
    ::int32_t threads_;
    ::int32_t random_seed_;
    int lp_algorithm_;
    int presolve_;
    int cuts_;
    int heuristics_;
    int scaling_;
    double relative_gap_tolerance_;
    double absolute_gap_tolerance_;
    double cutoff_limit_;
    double objective_limit_;
    double best_bound_limit_;
    ::int64_t node_limit_;
    ::int32_t solution_limit_;
    ::int32_t solution_pool_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fparameters_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolveParametersProto_class_data_;
 
// ===================================================================
 
 
 
 
// ===================================================================
 
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// StrictnessProto
 
// bool bad_parameter = 1;
inline void StrictnessProto::clear_bad_parameter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bad_parameter_ = false;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline bool StrictnessProto::bad_parameter() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.StrictnessProto.bad_parameter)
  return _internal_bad_parameter();
}
inline void StrictnessProto::set_bad_parameter(bool value) {
  _internal_set_bad_parameter(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.StrictnessProto.bad_parameter)
}
inline bool StrictnessProto::_internal_bad_parameter() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.bad_parameter_;
}
inline void StrictnessProto::_internal_set_bad_parameter(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bad_parameter_ = value;
}
 
// -------------------------------------------------------------------
 
// SolverInitializerProto
 
// .operations_research.math_opt.GurobiInitializerProto gurobi = 1;
inline bool SolverInitializerProto::has_gurobi() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.gurobi_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::GurobiInitializerProto& SolverInitializerProto::_internal_gurobi() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::GurobiInitializerProto* p = _impl_.gurobi_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::GurobiInitializerProto&>(::operations_research::math_opt::_GurobiInitializerProto_default_instance_);
}
inline const ::operations_research::math_opt::GurobiInitializerProto& SolverInitializerProto::gurobi() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolverInitializerProto.gurobi)
  return _internal_gurobi();
}
inline void SolverInitializerProto::unsafe_arena_set_allocated_gurobi(
    ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.gurobi_);
  }
  _impl_.gurobi_ = reinterpret_cast<::operations_research::math_opt::GurobiInitializerProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolverInitializerProto.gurobi)
}
inline ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE SolverInitializerProto::release_gurobi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::GurobiInitializerProto* released = _impl_.gurobi_;
  _impl_.gurobi_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE SolverInitializerProto::unsafe_arena_release_gurobi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolverInitializerProto.gurobi)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::GurobiInitializerProto* temp = _impl_.gurobi_;
  _impl_.gurobi_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NONNULL SolverInitializerProto::_internal_mutable_gurobi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.gurobi_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::GurobiInitializerProto>(GetArena());
    _impl_.gurobi_ = reinterpret_cast<::operations_research::math_opt::GurobiInitializerProto*>(p);
  }
  return _impl_.gurobi_;
}
inline ::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NONNULL SolverInitializerProto::mutable_gurobi()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::GurobiInitializerProto* _msg = _internal_mutable_gurobi();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolverInitializerProto.gurobi)
  return _msg;
}
inline void SolverInitializerProto::set_allocated_gurobi(::operations_research::math_opt::GurobiInitializerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.gurobi_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
 
  _impl_.gurobi_ = reinterpret_cast<::operations_research::math_opt::GurobiInitializerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolverInitializerProto.gurobi)
}
 
// .operations_research.math_opt.XpressInitializerProto xpress = 3;
inline bool SolverInitializerProto::has_xpress() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.xpress_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::XpressInitializerProto& SolverInitializerProto::_internal_xpress() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::XpressInitializerProto* p = _impl_.xpress_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::XpressInitializerProto&>(::operations_research::math_opt::_XpressInitializerProto_default_instance_);
}
inline const ::operations_research::math_opt::XpressInitializerProto& SolverInitializerProto::xpress() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolverInitializerProto.xpress)
  return _internal_xpress();
}
inline void SolverInitializerProto::unsafe_arena_set_allocated_xpress(
    ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpress_);
  }
  _impl_.xpress_ = reinterpret_cast<::operations_research::math_opt::XpressInitializerProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolverInitializerProto.xpress)
}
inline ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE SolverInitializerProto::release_xpress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::XpressInitializerProto* released = _impl_.xpress_;
  _impl_.xpress_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE SolverInitializerProto::unsafe_arena_release_xpress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolverInitializerProto.xpress)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::XpressInitializerProto* temp = _impl_.xpress_;
  _impl_.xpress_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NONNULL SolverInitializerProto::_internal_mutable_xpress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.xpress_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::XpressInitializerProto>(GetArena());
    _impl_.xpress_ = reinterpret_cast<::operations_research::math_opt::XpressInitializerProto*>(p);
  }
  return _impl_.xpress_;
}
inline ::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NONNULL SolverInitializerProto::mutable_xpress()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::XpressInitializerProto* _msg = _internal_mutable_xpress();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolverInitializerProto.xpress)
  return _msg;
}
inline void SolverInitializerProto::set_allocated_xpress(::operations_research::math_opt::XpressInitializerProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpress_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
 
  _impl_.xpress_ = reinterpret_cast<::operations_research::math_opt::XpressInitializerProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolverInitializerProto.xpress)
}
 
// -------------------------------------------------------------------
 
// SolveParametersProto
 
// .google.protobuf.Duration time_limit = 1;
inline bool SolveParametersProto::has_time_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.time_limit_ != nullptr);
  return value;
}
inline const ::google::protobuf::Duration& SolveParametersProto::_internal_time_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::google::protobuf::Duration* p = _impl_.time_limit_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::protobuf::Duration&>(::google::protobuf::_Duration_default_instance_);
}
inline const ::google::protobuf::Duration& SolveParametersProto::time_limit() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.time_limit)
  return _internal_time_limit();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_time_limit(
    ::google::protobuf::Duration* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.time_limit_);
  }
  _impl_.time_limit_ = reinterpret_cast<::google::protobuf::Duration*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.time_limit)
}
inline ::google::protobuf::Duration* PROTOBUF_NULLABLE SolveParametersProto::release_time_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Duration* released = _impl_.time_limit_;
  _impl_.time_limit_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::google::protobuf::Duration* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_time_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.time_limit)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Duration* temp = _impl_.time_limit_;
  _impl_.time_limit_ = nullptr;
  return temp;
}
inline ::google::protobuf::Duration* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_time_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.time_limit_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena());
    _impl_.time_limit_ = reinterpret_cast<::google::protobuf::Duration*>(p);
  }
  return _impl_.time_limit_;
}
inline ::google::protobuf::Duration* PROTOBUF_NONNULL SolveParametersProto::mutable_time_limit()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Duration* _msg = _internal_mutable_time_limit();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.time_limit)
  return _msg;
}
inline void SolveParametersProto::set_allocated_time_limit(::google::protobuf::Duration* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.time_limit_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
 
  _impl_.time_limit_ = reinterpret_cast<::google::protobuf::Duration*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.time_limit)
}
 
// optional int64 iteration_limit = 2;
inline bool SolveParametersProto::has_iteration_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void SolveParametersProto::clear_iteration_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.iteration_limit_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000400U);
}
inline ::int64_t SolveParametersProto::iteration_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.iteration_limit)
  return _internal_iteration_limit();
}
inline void SolveParametersProto::set_iteration_limit(::int64_t value) {
  _internal_set_iteration_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.iteration_limit)
}
inline ::int64_t SolveParametersProto::_internal_iteration_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.iteration_limit_;
}
inline void SolveParametersProto::_internal_set_iteration_limit(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.iteration_limit_ = value;
}
 
// optional int64 node_limit = 24;
inline bool SolveParametersProto::has_node_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x01000000U);
  return value;
}
inline void SolveParametersProto::clear_node_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_limit_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x01000000U);
}
inline ::int64_t SolveParametersProto::node_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.node_limit)
  return _internal_node_limit();
}
inline void SolveParametersProto::set_node_limit(::int64_t value) {
  _internal_set_node_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.node_limit)
}
inline ::int64_t SolveParametersProto::_internal_node_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_limit_;
}
inline void SolveParametersProto::_internal_set_node_limit(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_limit_ = value;
}
 
// optional double cutoff_limit = 20;
inline bool SolveParametersProto::has_cutoff_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00200000U);
  return value;
}
inline void SolveParametersProto::clear_cutoff_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cutoff_limit_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00200000U);
}
inline double SolveParametersProto::cutoff_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.cutoff_limit)
  return _internal_cutoff_limit();
}
inline void SolveParametersProto::set_cutoff_limit(double value) {
  _internal_set_cutoff_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.cutoff_limit)
}
inline double SolveParametersProto::_internal_cutoff_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.cutoff_limit_;
}
inline void SolveParametersProto::_internal_set_cutoff_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cutoff_limit_ = value;
}
 
// optional double objective_limit = 21;
inline bool SolveParametersProto::has_objective_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00400000U);
  return value;
}
inline void SolveParametersProto::clear_objective_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_limit_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00400000U);
}
inline double SolveParametersProto::objective_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.objective_limit)
  return _internal_objective_limit();
}
inline void SolveParametersProto::set_objective_limit(double value) {
  _internal_set_objective_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.objective_limit)
}
inline double SolveParametersProto::_internal_objective_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.objective_limit_;
}
inline void SolveParametersProto::_internal_set_objective_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_limit_ = value;
}
 
// optional double best_bound_limit = 22;
inline bool SolveParametersProto::has_best_bound_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00800000U);
  return value;
}
inline void SolveParametersProto::clear_best_bound_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.best_bound_limit_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00800000U);
}
inline double SolveParametersProto::best_bound_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.best_bound_limit)
  return _internal_best_bound_limit();
}
inline void SolveParametersProto::set_best_bound_limit(double value) {
  _internal_set_best_bound_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.best_bound_limit)
}
inline double SolveParametersProto::_internal_best_bound_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.best_bound_limit_;
}
inline void SolveParametersProto::_internal_set_best_bound_limit(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.best_bound_limit_ = value;
}
 
// optional int32 solution_limit = 23;
inline bool SolveParametersProto::has_solution_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x02000000U);
  return value;
}
inline void SolveParametersProto::clear_solution_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_limit_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x02000000U);
}
inline ::int32_t SolveParametersProto::solution_limit() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.solution_limit)
  return _internal_solution_limit();
}
inline void SolveParametersProto::set_solution_limit(::int32_t value) {
  _internal_set_solution_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.solution_limit)
}
inline ::int32_t SolveParametersProto::_internal_solution_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.solution_limit_;
}
inline void SolveParametersProto::_internal_set_solution_limit(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_limit_ = value;
}
 
// bool enable_output = 3;
inline void SolveParametersProto::clear_enable_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_output_ = false;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000800U);
}
inline bool SolveParametersProto::enable_output() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.enable_output)
  return _internal_enable_output();
}
inline void SolveParametersProto::set_enable_output(bool value) {
  _internal_set_enable_output(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.enable_output)
}
inline bool SolveParametersProto::_internal_enable_output() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_output_;
}
inline void SolveParametersProto::_internal_set_enable_output(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_output_ = value;
}
 
// optional int32 threads = 4;
inline bool SolveParametersProto::has_threads() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void SolveParametersProto::clear_threads() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.threads_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00001000U);
}
inline ::int32_t SolveParametersProto::threads() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.threads)
  return _internal_threads();
}
inline void SolveParametersProto::set_threads(::int32_t value) {
  _internal_set_threads(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.threads)
}
inline ::int32_t SolveParametersProto::_internal_threads() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.threads_;
}
inline void SolveParametersProto::_internal_set_threads(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.threads_ = value;
}
 
// optional int32 random_seed = 5;
inline bool SolveParametersProto::has_random_seed() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void SolveParametersProto::clear_random_seed() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_seed_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00002000U);
}
inline ::int32_t SolveParametersProto::random_seed() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.random_seed)
  return _internal_random_seed();
}
inline void SolveParametersProto::set_random_seed(::int32_t value) {
  _internal_set_random_seed(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.random_seed)
}
inline ::int32_t SolveParametersProto::_internal_random_seed() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.random_seed_;
}
inline void SolveParametersProto::_internal_set_random_seed(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.random_seed_ = value;
}
 
// optional double absolute_gap_tolerance = 18;
inline bool SolveParametersProto::has_absolute_gap_tolerance() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00100000U);
  return value;
}
inline void SolveParametersProto::clear_absolute_gap_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.absolute_gap_tolerance_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00100000U);
}
inline double SolveParametersProto::absolute_gap_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.absolute_gap_tolerance)
  return _internal_absolute_gap_tolerance();
}
inline void SolveParametersProto::set_absolute_gap_tolerance(double value) {
  _internal_set_absolute_gap_tolerance(value);
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.absolute_gap_tolerance)
}
inline double SolveParametersProto::_internal_absolute_gap_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.absolute_gap_tolerance_;
}
inline void SolveParametersProto::_internal_set_absolute_gap_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.absolute_gap_tolerance_ = value;
}
 
// optional double relative_gap_tolerance = 17;
inline bool SolveParametersProto::has_relative_gap_tolerance() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00080000U);
  return value;
}
inline void SolveParametersProto::clear_relative_gap_tolerance() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.relative_gap_tolerance_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00080000U);
}
inline double SolveParametersProto::relative_gap_tolerance() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.relative_gap_tolerance)
  return _internal_relative_gap_tolerance();
}
inline void SolveParametersProto::set_relative_gap_tolerance(double value) {
  _internal_set_relative_gap_tolerance(value);
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.relative_gap_tolerance)
}
inline double SolveParametersProto::_internal_relative_gap_tolerance() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.relative_gap_tolerance_;
}
inline void SolveParametersProto::_internal_set_relative_gap_tolerance(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.relative_gap_tolerance_ = value;
}
 
// optional int32 solution_pool_size = 25;
inline bool SolveParametersProto::has_solution_pool_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x04000000U);
  return value;
}
inline void SolveParametersProto::clear_solution_pool_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_pool_size_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x04000000U);
}
inline ::int32_t SolveParametersProto::solution_pool_size() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.solution_pool_size)
  return _internal_solution_pool_size();
}
inline void SolveParametersProto::set_solution_pool_size(::int32_t value) {
  _internal_set_solution_pool_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.solution_pool_size)
}
inline ::int32_t SolveParametersProto::_internal_solution_pool_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.solution_pool_size_;
}
inline void SolveParametersProto::_internal_set_solution_pool_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.solution_pool_size_ = value;
}
 
// .operations_research.math_opt.LPAlgorithmProto lp_algorithm = 6;
inline void SolveParametersProto::clear_lp_algorithm() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lp_algorithm_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00004000U);
}
inline ::operations_research::math_opt::LPAlgorithmProto SolveParametersProto::lp_algorithm() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.lp_algorithm)
  return _internal_lp_algorithm();
}
inline void SolveParametersProto::set_lp_algorithm(::operations_research::math_opt::LPAlgorithmProto value) {
  _internal_set_lp_algorithm(value);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.lp_algorithm)
}
inline ::operations_research::math_opt::LPAlgorithmProto SolveParametersProto::_internal_lp_algorithm() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::LPAlgorithmProto>(_impl_.lp_algorithm_);
}
inline void SolveParametersProto::_internal_set_lp_algorithm(::operations_research::math_opt::LPAlgorithmProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.lp_algorithm_ = value;
}
 
// .operations_research.math_opt.EmphasisProto presolve = 7;
inline void SolveParametersProto::clear_presolve() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00008000U);
}
inline ::operations_research::math_opt::EmphasisProto SolveParametersProto::presolve() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.presolve)
  return _internal_presolve();
}
inline void SolveParametersProto::set_presolve(::operations_research::math_opt::EmphasisProto value) {
  _internal_set_presolve(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.presolve)
}
inline ::operations_research::math_opt::EmphasisProto SolveParametersProto::_internal_presolve() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::EmphasisProto>(_impl_.presolve_);
}
inline void SolveParametersProto::_internal_set_presolve(::operations_research::math_opt::EmphasisProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.presolve_ = value;
}
 
// .operations_research.math_opt.EmphasisProto cuts = 8;
inline void SolveParametersProto::clear_cuts() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cuts_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00010000U);
}
inline ::operations_research::math_opt::EmphasisProto SolveParametersProto::cuts() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.cuts)
  return _internal_cuts();
}
inline void SolveParametersProto::set_cuts(::operations_research::math_opt::EmphasisProto value) {
  _internal_set_cuts(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.cuts)
}
inline ::operations_research::math_opt::EmphasisProto SolveParametersProto::_internal_cuts() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::EmphasisProto>(_impl_.cuts_);
}
inline void SolveParametersProto::_internal_set_cuts(::operations_research::math_opt::EmphasisProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.cuts_ = value;
}
 
// .operations_research.math_opt.EmphasisProto heuristics = 9;
inline void SolveParametersProto::clear_heuristics() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.heuristics_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00020000U);
}
inline ::operations_research::math_opt::EmphasisProto SolveParametersProto::heuristics() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.heuristics)
  return _internal_heuristics();
}
inline void SolveParametersProto::set_heuristics(::operations_research::math_opt::EmphasisProto value) {
  _internal_set_heuristics(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.heuristics)
}
inline ::operations_research::math_opt::EmphasisProto SolveParametersProto::_internal_heuristics() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::EmphasisProto>(_impl_.heuristics_);
}
inline void SolveParametersProto::_internal_set_heuristics(::operations_research::math_opt::EmphasisProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.heuristics_ = value;
}
 
// .operations_research.math_opt.EmphasisProto scaling = 10;
inline void SolveParametersProto::clear_scaling() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.scaling_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00040000U);
}
inline ::operations_research::math_opt::EmphasisProto SolveParametersProto::scaling() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.scaling)
  return _internal_scaling();
}
inline void SolveParametersProto::set_scaling(::operations_research::math_opt::EmphasisProto value) {
  _internal_set_scaling(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveParametersProto.scaling)
}
inline ::operations_research::math_opt::EmphasisProto SolveParametersProto::_internal_scaling() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::EmphasisProto>(_impl_.scaling_);
}
inline void SolveParametersProto::_internal_set_scaling(::operations_research::math_opt::EmphasisProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.scaling_ = value;
}
 
// .operations_research.GScipParameters gscip = 12;
inline bool SolveParametersProto::has_gscip() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.gscip_ != nullptr);
  return value;
}
inline const ::operations_research::GScipParameters& SolveParametersProto::_internal_gscip() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::GScipParameters* p = _impl_.gscip_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::GScipParameters&>(::operations_research::_GScipParameters_default_instance_);
}
inline const ::operations_research::GScipParameters& SolveParametersProto::gscip() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.gscip)
  return _internal_gscip();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_gscip(
    ::operations_research::GScipParameters* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.gscip_);
  }
  _impl_.gscip_ = reinterpret_cast<::operations_research::GScipParameters*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.gscip)
}
inline ::operations_research::GScipParameters* PROTOBUF_NULLABLE SolveParametersProto::release_gscip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::GScipParameters* released = _impl_.gscip_;
  _impl_.gscip_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::GScipParameters* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_gscip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.gscip)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::GScipParameters* temp = _impl_.gscip_;
  _impl_.gscip_ = nullptr;
  return temp;
}
inline ::operations_research::GScipParameters* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_gscip() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.gscip_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::GScipParameters>(GetArena());
    _impl_.gscip_ = reinterpret_cast<::operations_research::GScipParameters*>(p);
  }
  return _impl_.gscip_;
}
inline ::operations_research::GScipParameters* PROTOBUF_NONNULL SolveParametersProto::mutable_gscip()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::GScipParameters* _msg = _internal_mutable_gscip();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.gscip)
  return _msg;
}
inline void SolveParametersProto::set_allocated_gscip(::operations_research::GScipParameters* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.gscip_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
 
  _impl_.gscip_ = reinterpret_cast<::operations_research::GScipParameters*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.gscip)
}
 
// .operations_research.math_opt.GurobiParametersProto gurobi = 13;
inline bool SolveParametersProto::has_gurobi() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.gurobi_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::GurobiParametersProto& SolveParametersProto::_internal_gurobi() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::GurobiParametersProto* p = _impl_.gurobi_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::GurobiParametersProto&>(::operations_research::math_opt::_GurobiParametersProto_default_instance_);
}
inline const ::operations_research::math_opt::GurobiParametersProto& SolveParametersProto::gurobi() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.gurobi)
  return _internal_gurobi();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_gurobi(
    ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.gurobi_);
  }
  _impl_.gurobi_ = reinterpret_cast<::operations_research::math_opt::GurobiParametersProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.gurobi)
}
inline ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE SolveParametersProto::release_gurobi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::GurobiParametersProto* released = _impl_.gurobi_;
  _impl_.gurobi_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_gurobi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.gurobi)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::GurobiParametersProto* temp = _impl_.gurobi_;
  _impl_.gurobi_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_gurobi() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.gurobi_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::GurobiParametersProto>(GetArena());
    _impl_.gurobi_ = reinterpret_cast<::operations_research::math_opt::GurobiParametersProto*>(p);
  }
  return _impl_.gurobi_;
}
inline ::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NONNULL SolveParametersProto::mutable_gurobi()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::GurobiParametersProto* _msg = _internal_mutable_gurobi();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.gurobi)
  return _msg;
}
inline void SolveParametersProto::set_allocated_gurobi(::operations_research::math_opt::GurobiParametersProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.gurobi_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
 
  _impl_.gurobi_ = reinterpret_cast<::operations_research::math_opt::GurobiParametersProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.gurobi)
}
 
// .operations_research.glop.GlopParameters glop = 14;
inline bool SolveParametersProto::has_glop() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.glop_ != nullptr);
  return value;
}
inline const ::operations_research::glop::GlopParameters& SolveParametersProto::_internal_glop() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::glop::GlopParameters* p = _impl_.glop_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::glop::GlopParameters&>(::operations_research::glop::_GlopParameters_default_instance_);
}
inline const ::operations_research::glop::GlopParameters& SolveParametersProto::glop() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.glop)
  return _internal_glop();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_glop(
    ::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.glop_);
  }
  _impl_.glop_ = reinterpret_cast<::operations_research::glop::GlopParameters*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.glop)
}
inline ::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE SolveParametersProto::release_glop() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::operations_research::glop::GlopParameters* released = _impl_.glop_;
  _impl_.glop_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_glop() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.glop)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::operations_research::glop::GlopParameters* temp = _impl_.glop_;
  _impl_.glop_ = nullptr;
  return temp;
}
inline ::operations_research::glop::GlopParameters* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_glop() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.glop_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::glop::GlopParameters>(GetArena());
    _impl_.glop_ = reinterpret_cast<::operations_research::glop::GlopParameters*>(p);
  }
  return _impl_.glop_;
}
inline ::operations_research::glop::GlopParameters* PROTOBUF_NONNULL SolveParametersProto::mutable_glop()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::operations_research::glop::GlopParameters* _msg = _internal_mutable_glop();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.glop)
  return _msg;
}
inline void SolveParametersProto::set_allocated_glop(::operations_research::glop::GlopParameters* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.glop_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
 
  _impl_.glop_ = reinterpret_cast<::operations_research::glop::GlopParameters*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.glop)
}
 
// .operations_research.sat.SatParameters cp_sat = 15;
inline bool SolveParametersProto::has_cp_sat() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.cp_sat_ != nullptr);
  return value;
}
inline const ::operations_research::sat::SatParameters& SolveParametersProto::_internal_cp_sat() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::sat::SatParameters* p = _impl_.cp_sat_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::sat::SatParameters&>(::operations_research::sat::_SatParameters_default_instance_);
}
inline const ::operations_research::sat::SatParameters& SolveParametersProto::cp_sat() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.cp_sat)
  return _internal_cp_sat();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_cp_sat(
    ::operations_research::sat::SatParameters* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cp_sat_);
  }
  _impl_.cp_sat_ = reinterpret_cast<::operations_research::sat::SatParameters*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.cp_sat)
}
inline ::operations_research::sat::SatParameters* PROTOBUF_NULLABLE SolveParametersProto::release_cp_sat() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::operations_research::sat::SatParameters* released = _impl_.cp_sat_;
  _impl_.cp_sat_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::sat::SatParameters* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_cp_sat() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.cp_sat)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::operations_research::sat::SatParameters* temp = _impl_.cp_sat_;
  _impl_.cp_sat_ = nullptr;
  return temp;
}
inline ::operations_research::sat::SatParameters* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_cp_sat() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.cp_sat_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::sat::SatParameters>(GetArena());
    _impl_.cp_sat_ = reinterpret_cast<::operations_research::sat::SatParameters*>(p);
  }
  return _impl_.cp_sat_;
}
inline ::operations_research::sat::SatParameters* PROTOBUF_NONNULL SolveParametersProto::mutable_cp_sat()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::operations_research::sat::SatParameters* _msg = _internal_mutable_cp_sat();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.cp_sat)
  return _msg;
}
inline void SolveParametersProto::set_allocated_cp_sat(::operations_research::sat::SatParameters* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.cp_sat_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
 
  _impl_.cp_sat_ = reinterpret_cast<::operations_research::sat::SatParameters*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.cp_sat)
}
 
// .operations_research.pdlp.PrimalDualHybridGradientParams pdlp = 16;
inline bool SolveParametersProto::has_pdlp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  PROTOBUF_ASSUME(!value || _impl_.pdlp_ != nullptr);
  return value;
}
inline const ::operations_research::pdlp::PrimalDualHybridGradientParams& SolveParametersProto::_internal_pdlp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::pdlp::PrimalDualHybridGradientParams* p = _impl_.pdlp_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::pdlp::PrimalDualHybridGradientParams&>(::operations_research::pdlp::_PrimalDualHybridGradientParams_default_instance_);
}
inline const ::operations_research::pdlp::PrimalDualHybridGradientParams& SolveParametersProto::pdlp() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.pdlp)
  return _internal_pdlp();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_pdlp(
    ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.pdlp_);
  }
  _impl_.pdlp_ = reinterpret_cast<::operations_research::pdlp::PrimalDualHybridGradientParams*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.pdlp)
}
inline ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE SolveParametersProto::release_pdlp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::operations_research::pdlp::PrimalDualHybridGradientParams* released = _impl_.pdlp_;
  _impl_.pdlp_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_pdlp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.pdlp)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::operations_research::pdlp::PrimalDualHybridGradientParams* temp = _impl_.pdlp_;
  _impl_.pdlp_ = nullptr;
  return temp;
}
inline ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_pdlp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.pdlp_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::pdlp::PrimalDualHybridGradientParams>(GetArena());
    _impl_.pdlp_ = reinterpret_cast<::operations_research::pdlp::PrimalDualHybridGradientParams*>(p);
  }
  return _impl_.pdlp_;
}
inline ::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NONNULL SolveParametersProto::mutable_pdlp()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::operations_research::pdlp::PrimalDualHybridGradientParams* _msg = _internal_mutable_pdlp();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.pdlp)
  return _msg;
}
inline void SolveParametersProto::set_allocated_pdlp(::operations_research::pdlp::PrimalDualHybridGradientParams* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.pdlp_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
 
  _impl_.pdlp_ = reinterpret_cast<::operations_research::pdlp::PrimalDualHybridGradientParams*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.pdlp)
}
 
// .operations_research.math_opt.OsqpSettingsProto osqp = 19;
inline bool SolveParametersProto::has_osqp() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  PROTOBUF_ASSUME(!value || _impl_.osqp_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::OsqpSettingsProto& SolveParametersProto::_internal_osqp() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::OsqpSettingsProto* p = _impl_.osqp_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::OsqpSettingsProto&>(::operations_research::math_opt::_OsqpSettingsProto_default_instance_);
}
inline const ::operations_research::math_opt::OsqpSettingsProto& SolveParametersProto::osqp() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.osqp)
  return _internal_osqp();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_osqp(
    ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.osqp_);
  }
  _impl_.osqp_ = reinterpret_cast<::operations_research::math_opt::OsqpSettingsProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.osqp)
}
inline ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE SolveParametersProto::release_osqp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::operations_research::math_opt::OsqpSettingsProto* released = _impl_.osqp_;
  _impl_.osqp_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_osqp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.osqp)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::operations_research::math_opt::OsqpSettingsProto* temp = _impl_.osqp_;
  _impl_.osqp_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_osqp() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.osqp_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::OsqpSettingsProto>(GetArena());
    _impl_.osqp_ = reinterpret_cast<::operations_research::math_opt::OsqpSettingsProto*>(p);
  }
  return _impl_.osqp_;
}
inline ::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NONNULL SolveParametersProto::mutable_osqp()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::operations_research::math_opt::OsqpSettingsProto* _msg = _internal_mutable_osqp();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.osqp)
  return _msg;
}
inline void SolveParametersProto::set_allocated_osqp(::operations_research::math_opt::OsqpSettingsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.osqp_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
 
  _impl_.osqp_ = reinterpret_cast<::operations_research::math_opt::OsqpSettingsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.osqp)
}
 
// .operations_research.math_opt.GlpkParametersProto glpk = 26;
inline bool SolveParametersProto::has_glpk() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  PROTOBUF_ASSUME(!value || _impl_.glpk_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::GlpkParametersProto& SolveParametersProto::_internal_glpk() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::GlpkParametersProto* p = _impl_.glpk_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::GlpkParametersProto&>(::operations_research::math_opt::_GlpkParametersProto_default_instance_);
}
inline const ::operations_research::math_opt::GlpkParametersProto& SolveParametersProto::glpk() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.glpk)
  return _internal_glpk();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_glpk(
    ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.glpk_);
  }
  _impl_.glpk_ = reinterpret_cast<::operations_research::math_opt::GlpkParametersProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.glpk)
}
inline ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE SolveParametersProto::release_glpk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::operations_research::math_opt::GlpkParametersProto* released = _impl_.glpk_;
  _impl_.glpk_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_glpk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.glpk)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::operations_research::math_opt::GlpkParametersProto* temp = _impl_.glpk_;
  _impl_.glpk_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_glpk() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.glpk_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::GlpkParametersProto>(GetArena());
    _impl_.glpk_ = reinterpret_cast<::operations_research::math_opt::GlpkParametersProto*>(p);
  }
  return _impl_.glpk_;
}
inline ::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NONNULL SolveParametersProto::mutable_glpk()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::operations_research::math_opt::GlpkParametersProto* _msg = _internal_mutable_glpk();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.glpk)
  return _msg;
}
inline void SolveParametersProto::set_allocated_glpk(::operations_research::math_opt::GlpkParametersProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.glpk_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
 
  _impl_.glpk_ = reinterpret_cast<::operations_research::math_opt::GlpkParametersProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.glpk)
}
 
// .operations_research.math_opt.HighsOptionsProto highs = 27;
inline bool SolveParametersProto::has_highs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  PROTOBUF_ASSUME(!value || _impl_.highs_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::HighsOptionsProto& SolveParametersProto::_internal_highs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::HighsOptionsProto* p = _impl_.highs_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::HighsOptionsProto&>(::operations_research::math_opt::_HighsOptionsProto_default_instance_);
}
inline const ::operations_research::math_opt::HighsOptionsProto& SolveParametersProto::highs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.highs)
  return _internal_highs();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_highs(
    ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.highs_);
  }
  _impl_.highs_ = reinterpret_cast<::operations_research::math_opt::HighsOptionsProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.highs)
}
inline ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE SolveParametersProto::release_highs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::operations_research::math_opt::HighsOptionsProto* released = _impl_.highs_;
  _impl_.highs_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_highs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.highs)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::operations_research::math_opt::HighsOptionsProto* temp = _impl_.highs_;
  _impl_.highs_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_highs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.highs_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::HighsOptionsProto>(GetArena());
    _impl_.highs_ = reinterpret_cast<::operations_research::math_opt::HighsOptionsProto*>(p);
  }
  return _impl_.highs_;
}
inline ::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NONNULL SolveParametersProto::mutable_highs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  ::operations_research::math_opt::HighsOptionsProto* _msg = _internal_mutable_highs();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.highs)
  return _msg;
}
inline void SolveParametersProto::set_allocated_highs(::operations_research::math_opt::HighsOptionsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.highs_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
  }
 
  _impl_.highs_ = reinterpret_cast<::operations_research::math_opt::HighsOptionsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.highs)
}
 
// .operations_research.math_opt.XpressParametersProto xpress = 28;
inline bool SolveParametersProto::has_xpress() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  PROTOBUF_ASSUME(!value || _impl_.xpress_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::XpressParametersProto& SolveParametersProto::_internal_xpress() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::XpressParametersProto* p = _impl_.xpress_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::XpressParametersProto&>(::operations_research::math_opt::_XpressParametersProto_default_instance_);
}
inline const ::operations_research::math_opt::XpressParametersProto& SolveParametersProto::xpress() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveParametersProto.xpress)
  return _internal_xpress();
}
inline void SolveParametersProto::unsafe_arena_set_allocated_xpress(
    ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpress_);
  }
  _impl_.xpress_ = reinterpret_cast<::operations_research::math_opt::XpressParametersProto*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveParametersProto.xpress)
}
inline ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE SolveParametersProto::release_xpress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::operations_research::math_opt::XpressParametersProto* released = _impl_.xpress_;
  _impl_.xpress_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE SolveParametersProto::unsafe_arena_release_xpress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveParametersProto.xpress)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::operations_research::math_opt::XpressParametersProto* temp = _impl_.xpress_;
  _impl_.xpress_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NONNULL SolveParametersProto::_internal_mutable_xpress() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.xpress_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::XpressParametersProto>(GetArena());
    _impl_.xpress_ = reinterpret_cast<::operations_research::math_opt::XpressParametersProto*>(p);
  }
  return _impl_.xpress_;
}
inline ::operations_research::math_opt::XpressParametersProto* PROTOBUF_NONNULL SolveParametersProto::mutable_xpress()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  ::operations_research::math_opt::XpressParametersProto* _msg = _internal_mutable_xpress();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveParametersProto.xpress)
  return _msg;
}
inline void SolveParametersProto::set_allocated_xpress(::operations_research::math_opt::XpressParametersProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.xpress_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
  }
 
  _impl_.xpress_ = reinterpret_cast<::operations_research::math_opt::XpressParametersProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveParametersProto.xpress)
}
 
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__
 
// @@protoc_insertion_point(namespace_scope)
}  // namespace math_opt
}  // namespace operations_research
 
 
namespace google {
namespace protobuf {
 
template <>
struct is_proto_enum<::operations_research::math_opt::SolverTypeProto> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::math_opt::SolverTypeProto>() {
  return ::operations_research::math_opt::SolverTypeProto_descriptor();
}
template <>
struct is_proto_enum<::operations_research::math_opt::LPAlgorithmProto> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::math_opt::LPAlgorithmProto>() {
  return ::operations_research::math_opt::LPAlgorithmProto_descriptor();
}
template <>
struct is_proto_enum<::operations_research::math_opt::EmphasisProto> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::math_opt::EmphasisProto>() {
  return ::operations_research::math_opt::EmphasisProto_descriptor();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#include "google/protobuf/port_undef.inc"
 
#endif  // ortools_2fmath_5fopt_2fparameters_2eproto_2epb_2eh