result.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/result.proto
// Protobuf C++ Version: 6.33.1
 
#ifndef ortools_2fmath_5fopt_2fresult_2eproto_2epb_2eh
#define ortools_2fmath_5fopt_2fresult_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/solve_log.pb.h"
#include "ortools/math_opt/solution.pb.h"
#include "ortools/math_opt/solvers/gscip/gscip.pb.h"
#include "ortools/math_opt/solvers/osqp.pb.h"
// @@protoc_insertion_point(includes)
 
// Must be included last.
#include "google/protobuf/port_def.inc"
 
#define PROTOBUF_INTERNAL_EXPORT_ortools_2fmath_5fopt_2fresult_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_2fresult_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
OR_PROTO_DLL extern const ::google::protobuf::internal::DescriptorTable descriptor_table_ortools_2fmath_5fopt_2fresult_2eproto;
}  // extern "C"
namespace operations_research {
namespace math_opt {
enum FeasibilityStatusProto : int;
OR_PROTO_DLL extern const uint32_t FeasibilityStatusProto_internal_data_[];
enum LimitProto : int;
OR_PROTO_DLL extern const uint32_t LimitProto_internal_data_[];
enum TerminationReasonProto : int;
OR_PROTO_DLL extern const uint32_t TerminationReasonProto_internal_data_[];
class ObjectiveBoundsProto;
struct ObjectiveBoundsProtoDefaultTypeInternal;
OR_PROTO_DLL extern ObjectiveBoundsProtoDefaultTypeInternal _ObjectiveBoundsProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull ObjectiveBoundsProto_class_data_;
class ProblemStatusProto;
struct ProblemStatusProtoDefaultTypeInternal;
OR_PROTO_DLL extern ProblemStatusProtoDefaultTypeInternal _ProblemStatusProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull ProblemStatusProto_class_data_;
class SolveResultProto;
struct SolveResultProtoDefaultTypeInternal;
OR_PROTO_DLL extern SolveResultProtoDefaultTypeInternal _SolveResultProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolveResultProto_class_data_;
class SolveResultProto_PdlpOutput;
struct SolveResultProto_PdlpOutputDefaultTypeInternal;
OR_PROTO_DLL extern SolveResultProto_PdlpOutputDefaultTypeInternal _SolveResultProto_PdlpOutput_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolveResultProto_PdlpOutput_class_data_;
class SolveStatsProto;
struct SolveStatsProtoDefaultTypeInternal;
OR_PROTO_DLL extern SolveStatsProtoDefaultTypeInternal _SolveStatsProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolveStatsProto_class_data_;
class TerminationProto;
struct TerminationProtoDefaultTypeInternal;
OR_PROTO_DLL extern TerminationProtoDefaultTypeInternal _TerminationProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull TerminationProto_class_data_;
}  // namespace math_opt
}  // namespace operations_research
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::operations_research::math_opt::FeasibilityStatusProto_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::math_opt::FeasibilityStatusProto>;
template <>
internal::EnumTraitsT<::operations_research::math_opt::LimitProto_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::math_opt::LimitProto>;
template <>
internal::EnumTraitsT<::operations_research::math_opt::TerminationReasonProto_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::math_opt::TerminationReasonProto>;
}  // namespace protobuf
}  // namespace google
 
namespace operations_research {
namespace math_opt {
enum FeasibilityStatusProto : int {
  FEASIBILITY_STATUS_UNSPECIFIED = 0,
  FEASIBILITY_STATUS_UNDETERMINED = 1,
  FEASIBILITY_STATUS_FEASIBLE = 2,
  FEASIBILITY_STATUS_INFEASIBLE = 3,
  FeasibilityStatusProto_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  FeasibilityStatusProto_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};
 
OR_PROTO_DLL extern const uint32_t FeasibilityStatusProto_internal_data_[];
inline constexpr FeasibilityStatusProto FeasibilityStatusProto_MIN =
    static_cast<FeasibilityStatusProto>(0);
inline constexpr FeasibilityStatusProto FeasibilityStatusProto_MAX =
    static_cast<FeasibilityStatusProto>(3);
inline bool FeasibilityStatusProto_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int FeasibilityStatusProto_ARRAYSIZE = 3 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL FeasibilityStatusProto_descriptor();
template <typename T>
const ::std::string& FeasibilityStatusProto_Name(T value) {
  static_assert(::std::is_same<T, FeasibilityStatusProto>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to FeasibilityStatusProto_Name().");
  return FeasibilityStatusProto_Name(static_cast<FeasibilityStatusProto>(value));
}
template <>
inline const ::std::string& FeasibilityStatusProto_Name(FeasibilityStatusProto value) {
  return ::google::protobuf::internal::NameOfDenseEnum<FeasibilityStatusProto_descriptor, 0, 3>(
      static_cast<int>(value));
}
inline bool FeasibilityStatusProto_Parse(
    ::absl::string_view name, FeasibilityStatusProto* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<FeasibilityStatusProto>(FeasibilityStatusProto_descriptor(), name,
                                           value);
}
enum TerminationReasonProto : int {
  TERMINATION_REASON_UNSPECIFIED = 0,
  TERMINATION_REASON_OPTIMAL = 1,
  TERMINATION_REASON_INFEASIBLE = 2,
  TERMINATION_REASON_UNBOUNDED = 3,
  TERMINATION_REASON_INFEASIBLE_OR_UNBOUNDED = 4,
  TERMINATION_REASON_IMPRECISE = 5,
  TERMINATION_REASON_FEASIBLE = 9,
  TERMINATION_REASON_NO_SOLUTION_FOUND = 6,
  TERMINATION_REASON_NUMERICAL_ERROR = 7,
  TERMINATION_REASON_OTHER_ERROR = 8,
  TerminationReasonProto_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  TerminationReasonProto_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};
 
OR_PROTO_DLL extern const uint32_t TerminationReasonProto_internal_data_[];
inline constexpr TerminationReasonProto TerminationReasonProto_MIN =
    static_cast<TerminationReasonProto>(0);
inline constexpr TerminationReasonProto TerminationReasonProto_MAX =
    static_cast<TerminationReasonProto>(9);
inline bool TerminationReasonProto_IsValid(int value) {
  return 0 <= value && value <= 9;
}
inline constexpr int TerminationReasonProto_ARRAYSIZE = 9 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL TerminationReasonProto_descriptor();
template <typename T>
const ::std::string& TerminationReasonProto_Name(T value) {
  static_assert(::std::is_same<T, TerminationReasonProto>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to TerminationReasonProto_Name().");
  return TerminationReasonProto_Name(static_cast<TerminationReasonProto>(value));
}
template <>
inline const ::std::string& TerminationReasonProto_Name(TerminationReasonProto value) {
  return ::google::protobuf::internal::NameOfDenseEnum<TerminationReasonProto_descriptor, 0, 9>(
      static_cast<int>(value));
}
inline bool TerminationReasonProto_Parse(
    ::absl::string_view name, TerminationReasonProto* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<TerminationReasonProto>(TerminationReasonProto_descriptor(), name,
                                           value);
}
enum LimitProto : int {
  LIMIT_UNSPECIFIED = 0,
  LIMIT_UNDETERMINED = 1,
  LIMIT_ITERATION = 2,
  LIMIT_TIME = 3,
  LIMIT_NODE = 4,
  LIMIT_SOLUTION = 5,
  LIMIT_MEMORY = 6,
  LIMIT_CUTOFF = 12,
  LIMIT_OBJECTIVE = 7,
  LIMIT_NORM = 8,
  LIMIT_INTERRUPTED = 9,
  LIMIT_SLOW_PROGRESS = 10,
  LIMIT_OTHER = 11,
  LimitProto_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  LimitProto_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};
 
OR_PROTO_DLL extern const uint32_t LimitProto_internal_data_[];
inline constexpr LimitProto LimitProto_MIN =
    static_cast<LimitProto>(0);
inline constexpr LimitProto LimitProto_MAX =
    static_cast<LimitProto>(12);
inline bool LimitProto_IsValid(int value) {
  return 0 <= value && value <= 12;
}
inline constexpr int LimitProto_ARRAYSIZE = 12 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL LimitProto_descriptor();
template <typename T>
const ::std::string& LimitProto_Name(T value) {
  static_assert(::std::is_same<T, LimitProto>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to LimitProto_Name().");
  return LimitProto_Name(static_cast<LimitProto>(value));
}
template <>
inline const ::std::string& LimitProto_Name(LimitProto value) {
  return ::google::protobuf::internal::NameOfDenseEnum<LimitProto_descriptor, 0, 12>(
      static_cast<int>(value));
}
inline bool LimitProto_Parse(
    ::absl::string_view name, LimitProto* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<LimitProto>(LimitProto_descriptor(), name,
                                           value);
}
 
// ===================================================================
 
 
// -------------------------------------------------------------------
 
class OR_PROTO_DLL ProblemStatusProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.ProblemStatusProto) */ {
 public:
  inline ProblemStatusProto() : ProblemStatusProto(nullptr) {}
  ~ProblemStatusProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ProblemStatusProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ProblemStatusProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ProblemStatusProto(::google::protobuf::internal::ConstantInitialized);
 
  inline ProblemStatusProto(const ProblemStatusProto& from) : ProblemStatusProto(nullptr, from) {}
  inline ProblemStatusProto(ProblemStatusProto&& from) noexcept
      : ProblemStatusProto(nullptr, ::std::move(from)) {}
  inline ProblemStatusProto& operator=(const ProblemStatusProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProblemStatusProto& operator=(ProblemStatusProto&& 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 ProblemStatusProto& default_instance() {
    return *reinterpret_cast<const ProblemStatusProto*>(
        &_ProblemStatusProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(ProblemStatusProto& a, ProblemStatusProto& b) { a.Swap(&b); }
  inline void Swap(ProblemStatusProto* 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(ProblemStatusProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  ProblemStatusProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ProblemStatusProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ProblemStatusProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ProblemStatusProto& from) { ProblemStatusProto::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(ProblemStatusProto* 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.ProblemStatusProto"; }
 
  explicit ProblemStatusProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ProblemStatusProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ProblemStatusProto& from);
  ProblemStatusProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ProblemStatusProto&& from) noexcept
      : ProblemStatusProto(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 {
    kPrimalStatusFieldNumber = 1,
    kDualStatusFieldNumber = 2,
    kPrimalOrDualInfeasibleFieldNumber = 3,
  };
  // .operations_research.math_opt.FeasibilityStatusProto primal_status = 1;
  void clear_primal_status() ;
  ::operations_research::math_opt::FeasibilityStatusProto primal_status() const;
  void set_primal_status(::operations_research::math_opt::FeasibilityStatusProto value);
 
  private:
  ::operations_research::math_opt::FeasibilityStatusProto _internal_primal_status() const;
  void _internal_set_primal_status(::operations_research::math_opt::FeasibilityStatusProto value);
 
  public:
  // .operations_research.math_opt.FeasibilityStatusProto dual_status = 2;
  void clear_dual_status() ;
  ::operations_research::math_opt::FeasibilityStatusProto dual_status() const;
  void set_dual_status(::operations_research::math_opt::FeasibilityStatusProto value);
 
  private:
  ::operations_research::math_opt::FeasibilityStatusProto _internal_dual_status() const;
  void _internal_set_dual_status(::operations_research::math_opt::FeasibilityStatusProto value);
 
  public:
  // bool primal_or_dual_infeasible = 3;
  void clear_primal_or_dual_infeasible() ;
  bool primal_or_dual_infeasible() const;
  void set_primal_or_dual_infeasible(bool value);
 
  private:
  bool _internal_primal_or_dual_infeasible() const;
  void _internal_set_primal_or_dual_infeasible(bool value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.ProblemStatusProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 3,
                                   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 ProblemStatusProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    int primal_status_;
    int dual_status_;
    bool primal_or_dual_infeasible_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fresult_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull ProblemStatusProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL ObjectiveBoundsProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.ObjectiveBoundsProto) */ {
 public:
  inline ObjectiveBoundsProto() : ObjectiveBoundsProto(nullptr) {}
  ~ObjectiveBoundsProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ObjectiveBoundsProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ObjectiveBoundsProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR ObjectiveBoundsProto(::google::protobuf::internal::ConstantInitialized);
 
  inline ObjectiveBoundsProto(const ObjectiveBoundsProto& from) : ObjectiveBoundsProto(nullptr, from) {}
  inline ObjectiveBoundsProto(ObjectiveBoundsProto&& from) noexcept
      : ObjectiveBoundsProto(nullptr, ::std::move(from)) {}
  inline ObjectiveBoundsProto& operator=(const ObjectiveBoundsProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ObjectiveBoundsProto& operator=(ObjectiveBoundsProto&& 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 ObjectiveBoundsProto& default_instance() {
    return *reinterpret_cast<const ObjectiveBoundsProto*>(
        &_ObjectiveBoundsProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(ObjectiveBoundsProto& a, ObjectiveBoundsProto& b) { a.Swap(&b); }
  inline void Swap(ObjectiveBoundsProto* 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(ObjectiveBoundsProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  ObjectiveBoundsProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<ObjectiveBoundsProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const ObjectiveBoundsProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const ObjectiveBoundsProto& from) { ObjectiveBoundsProto::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(ObjectiveBoundsProto* 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.ObjectiveBoundsProto"; }
 
  explicit ObjectiveBoundsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ObjectiveBoundsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ObjectiveBoundsProto& from);
  ObjectiveBoundsProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ObjectiveBoundsProto&& from) noexcept
      : ObjectiveBoundsProto(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 {
    kPrimalBoundFieldNumber = 2,
    kDualBoundFieldNumber = 3,
  };
  // double primal_bound = 2;
  void clear_primal_bound() ;
  double primal_bound() const;
  void set_primal_bound(double value);
 
  private:
  double _internal_primal_bound() const;
  void _internal_set_primal_bound(double value);
 
  public:
  // double dual_bound = 3;
  void clear_dual_bound() ;
  double dual_bound() const;
  void set_dual_bound(double value);
 
  private:
  double _internal_dual_bound() const;
  void _internal_set_dual_bound(double value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.ObjectiveBoundsProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<1, 2,
                                   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 ObjectiveBoundsProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    double primal_bound_;
    double dual_bound_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fresult_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull ObjectiveBoundsProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL TerminationProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.TerminationProto) */ {
 public:
  inline TerminationProto() : TerminationProto(nullptr) {}
  ~TerminationProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TerminationProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TerminationProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR TerminationProto(::google::protobuf::internal::ConstantInitialized);
 
  inline TerminationProto(const TerminationProto& from) : TerminationProto(nullptr, from) {}
  inline TerminationProto(TerminationProto&& from) noexcept
      : TerminationProto(nullptr, ::std::move(from)) {}
  inline TerminationProto& operator=(const TerminationProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline TerminationProto& operator=(TerminationProto&& 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 TerminationProto& default_instance() {
    return *reinterpret_cast<const TerminationProto*>(
        &_TerminationProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(TerminationProto& a, TerminationProto& b) { a.Swap(&b); }
  inline void Swap(TerminationProto* 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(TerminationProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  TerminationProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<TerminationProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const TerminationProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const TerminationProto& from) { TerminationProto::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(TerminationProto* 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.TerminationProto"; }
 
  explicit TerminationProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TerminationProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TerminationProto& from);
  TerminationProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TerminationProto&& from) noexcept
      : TerminationProto(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 {
    kDetailFieldNumber = 3,
    kProblemStatusFieldNumber = 4,
    kObjectiveBoundsFieldNumber = 5,
    kReasonFieldNumber = 1,
    kLimitFieldNumber = 2,
  };
  // string detail = 3;
  void clear_detail() ;
  const ::std::string& detail() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_detail(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_detail();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_detail();
  void set_allocated_detail(::std::string* PROTOBUF_NULLABLE value);
 
  private:
  const ::std::string& _internal_detail() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_detail(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_detail();
 
  public:
  // .operations_research.math_opt.ProblemStatusProto problem_status = 4;
  bool has_problem_status() const;
  void clear_problem_status() ;
  const ::operations_research::math_opt::ProblemStatusProto& problem_status() const;
  [[nodiscard]] ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE release_problem_status();
  ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NONNULL mutable_problem_status();
  void set_allocated_problem_status(::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_problem_status(::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE unsafe_arena_release_problem_status();
 
  private:
  const ::operations_research::math_opt::ProblemStatusProto& _internal_problem_status() const;
  ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NONNULL _internal_mutable_problem_status();
 
  public:
  // .operations_research.math_opt.ObjectiveBoundsProto objective_bounds = 5;
  bool has_objective_bounds() const;
  void clear_objective_bounds() ;
  const ::operations_research::math_opt::ObjectiveBoundsProto& objective_bounds() const;
  [[nodiscard]] ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NULLABLE release_objective_bounds();
  ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NONNULL mutable_objective_bounds();
  void set_allocated_objective_bounds(::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_objective_bounds(::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NULLABLE unsafe_arena_release_objective_bounds();
 
  private:
  const ::operations_research::math_opt::ObjectiveBoundsProto& _internal_objective_bounds() const;
  ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NONNULL _internal_mutable_objective_bounds();
 
  public:
  // .operations_research.math_opt.TerminationReasonProto reason = 1;
  void clear_reason() ;
  ::operations_research::math_opt::TerminationReasonProto reason() const;
  void set_reason(::operations_research::math_opt::TerminationReasonProto value);
 
  private:
  ::operations_research::math_opt::TerminationReasonProto _internal_reason() const;
  void _internal_set_reason(::operations_research::math_opt::TerminationReasonProto value);
 
  public:
  // .operations_research.math_opt.LimitProto limit = 2;
  void clear_limit() ;
  ::operations_research::math_opt::LimitProto limit() const;
  void set_limit(::operations_research::math_opt::LimitProto value);
 
  private:
  ::operations_research::math_opt::LimitProto _internal_limit() const;
  void _internal_set_limit(::operations_research::math_opt::LimitProto value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.TerminationProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<3, 5,
                                   2, 60,
                                   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 TerminationProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr detail_;
    ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE problem_status_;
    ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NULLABLE objective_bounds_;
    int reason_;
    int limit_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fresult_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull TerminationProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL SolveStatsProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.SolveStatsProto) */ {
 public:
  inline SolveStatsProto() : SolveStatsProto(nullptr) {}
  ~SolveStatsProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SolveStatsProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SolveStatsProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR SolveStatsProto(::google::protobuf::internal::ConstantInitialized);
 
  inline SolveStatsProto(const SolveStatsProto& from) : SolveStatsProto(nullptr, from) {}
  inline SolveStatsProto(SolveStatsProto&& from) noexcept
      : SolveStatsProto(nullptr, ::std::move(from)) {}
  inline SolveStatsProto& operator=(const SolveStatsProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SolveStatsProto& operator=(SolveStatsProto&& 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 SolveStatsProto& default_instance() {
    return *reinterpret_cast<const SolveStatsProto*>(
        &_SolveStatsProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(SolveStatsProto& a, SolveStatsProto& b) { a.Swap(&b); }
  inline void Swap(SolveStatsProto* 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(SolveStatsProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SolveStatsProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SolveStatsProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SolveStatsProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SolveStatsProto& from) { SolveStatsProto::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(SolveStatsProto* 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.SolveStatsProto"; }
 
  explicit SolveStatsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SolveStatsProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SolveStatsProto& from);
  SolveStatsProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SolveStatsProto&& from) noexcept
      : SolveStatsProto(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 {
    kSolveTimeFieldNumber = 1,
    kProblemStatusFieldNumber = 4,
    kBestPrimalBoundFieldNumber = 2,
    kBestDualBoundFieldNumber = 3,
    kSimplexIterationsFieldNumber = 5,
    kBarrierIterationsFieldNumber = 6,
    kNodeCountFieldNumber = 7,
    kFirstOrderIterationsFieldNumber = 8,
  };
  // .google.protobuf.Duration solve_time = 1;
  bool has_solve_time() const;
  void clear_solve_time() ;
  const ::google::protobuf::Duration& solve_time() const;
  [[nodiscard]] ::google::protobuf::Duration* PROTOBUF_NULLABLE release_solve_time();
  ::google::protobuf::Duration* PROTOBUF_NONNULL mutable_solve_time();
  void set_allocated_solve_time(::google::protobuf::Duration* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_solve_time(::google::protobuf::Duration* PROTOBUF_NULLABLE value);
  ::google::protobuf::Duration* PROTOBUF_NULLABLE unsafe_arena_release_solve_time();
 
  private:
  const ::google::protobuf::Duration& _internal_solve_time() const;
  ::google::protobuf::Duration* PROTOBUF_NONNULL _internal_mutable_solve_time();
 
  public:
  // .operations_research.math_opt.ProblemStatusProto problem_status = 4 [deprecated = true];
  [[deprecated]]  bool has_problem_status() const;
  [[deprecated]]  void clear_problem_status() ;
  [[deprecated]] const ::operations_research::math_opt::ProblemStatusProto& problem_status() const;
  [[deprecated]] [[nodiscard]] ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE release_problem_status();
  [[deprecated]] ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NONNULL mutable_problem_status();
  [[deprecated]] void set_allocated_problem_status(::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE value);
  [[deprecated]] void unsafe_arena_set_allocated_problem_status(::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE value);
  [[deprecated]] ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE unsafe_arena_release_problem_status();
 
  private:
  const ::operations_research::math_opt::ProblemStatusProto& _internal_problem_status() const;
  ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NONNULL _internal_mutable_problem_status();
 
  public:
  // double best_primal_bound = 2 [deprecated = true];
  [[deprecated]]  void clear_best_primal_bound() ;
  [[deprecated]] double best_primal_bound() const;
  [[deprecated]] void set_best_primal_bound(double value);
 
  private:
  double _internal_best_primal_bound() const;
  void _internal_set_best_primal_bound(double value);
 
  public:
  // double best_dual_bound = 3 [deprecated = true];
  [[deprecated]]  void clear_best_dual_bound() ;
  [[deprecated]] double best_dual_bound() const;
  [[deprecated]] void set_best_dual_bound(double value);
 
  private:
  double _internal_best_dual_bound() const;
  void _internal_set_best_dual_bound(double value);
 
  public:
  // int64 simplex_iterations = 5;
  void clear_simplex_iterations() ;
  ::int64_t simplex_iterations() const;
  void set_simplex_iterations(::int64_t value);
 
  private:
  ::int64_t _internal_simplex_iterations() const;
  void _internal_set_simplex_iterations(::int64_t value);
 
  public:
  // int64 barrier_iterations = 6;
  void clear_barrier_iterations() ;
  ::int64_t barrier_iterations() const;
  void set_barrier_iterations(::int64_t value);
 
  private:
  ::int64_t _internal_barrier_iterations() const;
  void _internal_set_barrier_iterations(::int64_t value);
 
  public:
  // int64 node_count = 7;
  void clear_node_count() ;
  ::int64_t node_count() const;
  void set_node_count(::int64_t value);
 
  private:
  ::int64_t _internal_node_count() const;
  void _internal_set_node_count(::int64_t value);
 
  public:
  // int64 first_order_iterations = 8;
  void clear_first_order_iterations() ;
  ::int64_t first_order_iterations() const;
  void set_first_order_iterations(::int64_t value);
 
  private:
  ::int64_t _internal_first_order_iterations() const;
  void _internal_set_first_order_iterations(::int64_t value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.SolveStatsProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<3, 8,
                                   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 SolveStatsProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::Duration* PROTOBUF_NULLABLE solve_time_;
    ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE problem_status_;
    double best_primal_bound_;
    double best_dual_bound_;
    ::int64_t simplex_iterations_;
    ::int64_t barrier_iterations_;
    ::int64_t node_count_;
    ::int64_t first_order_iterations_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fresult_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolveStatsProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL SolveResultProto_PdlpOutput final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.SolveResultProto.PdlpOutput) */ {
 public:
  inline SolveResultProto_PdlpOutput() : SolveResultProto_PdlpOutput(nullptr) {}
  ~SolveResultProto_PdlpOutput() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SolveResultProto_PdlpOutput* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SolveResultProto_PdlpOutput));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR SolveResultProto_PdlpOutput(::google::protobuf::internal::ConstantInitialized);
 
  inline SolveResultProto_PdlpOutput(const SolveResultProto_PdlpOutput& from) : SolveResultProto_PdlpOutput(nullptr, from) {}
  inline SolveResultProto_PdlpOutput(SolveResultProto_PdlpOutput&& from) noexcept
      : SolveResultProto_PdlpOutput(nullptr, ::std::move(from)) {}
  inline SolveResultProto_PdlpOutput& operator=(const SolveResultProto_PdlpOutput& from) {
    CopyFrom(from);
    return *this;
  }
  inline SolveResultProto_PdlpOutput& operator=(SolveResultProto_PdlpOutput&& 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 SolveResultProto_PdlpOutput& default_instance() {
    return *reinterpret_cast<const SolveResultProto_PdlpOutput*>(
        &_SolveResultProto_PdlpOutput_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(SolveResultProto_PdlpOutput& a, SolveResultProto_PdlpOutput& b) { a.Swap(&b); }
  inline void Swap(SolveResultProto_PdlpOutput* 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(SolveResultProto_PdlpOutput* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SolveResultProto_PdlpOutput* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SolveResultProto_PdlpOutput>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SolveResultProto_PdlpOutput& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SolveResultProto_PdlpOutput& from) { SolveResultProto_PdlpOutput::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(SolveResultProto_PdlpOutput* 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.SolveResultProto.PdlpOutput"; }
 
  explicit SolveResultProto_PdlpOutput(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SolveResultProto_PdlpOutput(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SolveResultProto_PdlpOutput& from);
  SolveResultProto_PdlpOutput(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SolveResultProto_PdlpOutput&& from) noexcept
      : SolveResultProto_PdlpOutput(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 {
    kConvergenceInformationFieldNumber = 1,
  };
  // .operations_research.pdlp.ConvergenceInformation convergence_information = 1;
  bool has_convergence_information() const;
  void clear_convergence_information() ;
  const ::operations_research::pdlp::ConvergenceInformation& convergence_information() const;
  [[nodiscard]] ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NULLABLE release_convergence_information();
  ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NONNULL mutable_convergence_information();
  void set_allocated_convergence_information(::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_convergence_information(::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NULLABLE value);
  ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NULLABLE unsafe_arena_release_convergence_information();
 
  private:
  const ::operations_research::pdlp::ConvergenceInformation& _internal_convergence_information() const;
  ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NONNULL _internal_mutable_convergence_information();
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.SolveResultProto.PdlpOutput)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<0, 1,
                                   1, 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 SolveResultProto_PdlpOutput& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NULLABLE convergence_information_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fresult_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolveResultProto_PdlpOutput_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL SolveResultProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.SolveResultProto) */ {
 public:
  inline SolveResultProto() : SolveResultProto(nullptr) {}
  ~SolveResultProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SolveResultProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SolveResultProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR SolveResultProto(::google::protobuf::internal::ConstantInitialized);
 
  inline SolveResultProto(const SolveResultProto& from) : SolveResultProto(nullptr, from) {}
  inline SolveResultProto(SolveResultProto&& from) noexcept
      : SolveResultProto(nullptr, ::std::move(from)) {}
  inline SolveResultProto& operator=(const SolveResultProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SolveResultProto& operator=(SolveResultProto&& 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 SolveResultProto& default_instance() {
    return *reinterpret_cast<const SolveResultProto*>(
        &_SolveResultProto_default_instance_);
  }
  enum SolverSpecificOutputCase {
    kGscipOutput = 7,
    kOsqpOutput = 8,
    kPdlpOutput = 9,
    SOLVER_SPECIFIC_OUTPUT_NOT_SET = 0,
  };
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(SolveResultProto& a, SolveResultProto& b) { a.Swap(&b); }
  inline void Swap(SolveResultProto* 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(SolveResultProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SolveResultProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SolveResultProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SolveResultProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SolveResultProto& from) { SolveResultProto::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(SolveResultProto* 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.SolveResultProto"; }
 
  explicit SolveResultProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SolveResultProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SolveResultProto& from);
  SolveResultProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SolveResultProto&& from) noexcept
      : SolveResultProto(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 ----------------------------------------------------
  using PdlpOutput = SolveResultProto_PdlpOutput;
 
  // accessors -------------------------------------------------------
  enum : int {
    kSolutionsFieldNumber = 3,
    kPrimalRaysFieldNumber = 4,
    kDualRaysFieldNumber = 5,
    kTerminationFieldNumber = 2,
    kSolveStatsFieldNumber = 6,
    kGscipOutputFieldNumber = 7,
    kOsqpOutputFieldNumber = 8,
    kPdlpOutputFieldNumber = 9,
  };
  // repeated .operations_research.math_opt.SolutionProto solutions = 3;
  int solutions_size() const;
  private:
  int _internal_solutions_size() const;
 
  public:
  void clear_solutions() ;
  ::operations_research::math_opt::SolutionProto* PROTOBUF_NONNULL mutable_solutions(int index);
  ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::SolutionProto>* PROTOBUF_NONNULL mutable_solutions();
 
  private:
  const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::SolutionProto>& _internal_solutions() const;
  ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::SolutionProto>* PROTOBUF_NONNULL _internal_mutable_solutions();
  public:
  const ::operations_research::math_opt::SolutionProto& solutions(int index) const;
  ::operations_research::math_opt::SolutionProto* PROTOBUF_NONNULL add_solutions();
  const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::SolutionProto>& solutions() const;
  // repeated .operations_research.math_opt.PrimalRayProto primal_rays = 4;
  int primal_rays_size() const;
  private:
  int _internal_primal_rays_size() const;
 
  public:
  void clear_primal_rays() ;
  ::operations_research::math_opt::PrimalRayProto* PROTOBUF_NONNULL mutable_primal_rays(int index);
  ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::PrimalRayProto>* PROTOBUF_NONNULL mutable_primal_rays();
 
  private:
  const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::PrimalRayProto>& _internal_primal_rays() const;
  ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::PrimalRayProto>* PROTOBUF_NONNULL _internal_mutable_primal_rays();
  public:
  const ::operations_research::math_opt::PrimalRayProto& primal_rays(int index) const;
  ::operations_research::math_opt::PrimalRayProto* PROTOBUF_NONNULL add_primal_rays();
  const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::PrimalRayProto>& primal_rays() const;
  // repeated .operations_research.math_opt.DualRayProto dual_rays = 5;
  int dual_rays_size() const;
  private:
  int _internal_dual_rays_size() const;
 
  public:
  void clear_dual_rays() ;
  ::operations_research::math_opt::DualRayProto* PROTOBUF_NONNULL mutable_dual_rays(int index);
  ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::DualRayProto>* PROTOBUF_NONNULL mutable_dual_rays();
 
  private:
  const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::DualRayProto>& _internal_dual_rays() const;
  ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::DualRayProto>* PROTOBUF_NONNULL _internal_mutable_dual_rays();
  public:
  const ::operations_research::math_opt::DualRayProto& dual_rays(int index) const;
  ::operations_research::math_opt::DualRayProto* PROTOBUF_NONNULL add_dual_rays();
  const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::DualRayProto>& dual_rays() const;
  // .operations_research.math_opt.TerminationProto termination = 2;
  bool has_termination() const;
  void clear_termination() ;
  const ::operations_research::math_opt::TerminationProto& termination() const;
  [[nodiscard]] ::operations_research::math_opt::TerminationProto* PROTOBUF_NULLABLE release_termination();
  ::operations_research::math_opt::TerminationProto* PROTOBUF_NONNULL mutable_termination();
  void set_allocated_termination(::operations_research::math_opt::TerminationProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_termination(::operations_research::math_opt::TerminationProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::TerminationProto* PROTOBUF_NULLABLE unsafe_arena_release_termination();
 
  private:
  const ::operations_research::math_opt::TerminationProto& _internal_termination() const;
  ::operations_research::math_opt::TerminationProto* PROTOBUF_NONNULL _internal_mutable_termination();
 
  public:
  // .operations_research.math_opt.SolveStatsProto solve_stats = 6;
  bool has_solve_stats() const;
  void clear_solve_stats() ;
  const ::operations_research::math_opt::SolveStatsProto& solve_stats() const;
  [[nodiscard]] ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NULLABLE release_solve_stats();
  ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NONNULL mutable_solve_stats();
  void set_allocated_solve_stats(::operations_research::math_opt::SolveStatsProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_solve_stats(::operations_research::math_opt::SolveStatsProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NULLABLE unsafe_arena_release_solve_stats();
 
  private:
  const ::operations_research::math_opt::SolveStatsProto& _internal_solve_stats() const;
  ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NONNULL _internal_mutable_solve_stats();
 
  public:
  // .operations_research.GScipOutput gscip_output = 7;
  bool has_gscip_output() const;
  private:
  bool _internal_has_gscip_output() const;
 
  public:
  void clear_gscip_output() ;
  const ::operations_research::GScipOutput& gscip_output() const;
  [[nodiscard]] ::operations_research::GScipOutput* PROTOBUF_NULLABLE release_gscip_output();
  ::operations_research::GScipOutput* PROTOBUF_NONNULL mutable_gscip_output();
  void set_allocated_gscip_output(::operations_research::GScipOutput* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_gscip_output(::operations_research::GScipOutput* PROTOBUF_NULLABLE value);
  ::operations_research::GScipOutput* PROTOBUF_NULLABLE unsafe_arena_release_gscip_output();
 
  private:
  const ::operations_research::GScipOutput& _internal_gscip_output() const;
  ::operations_research::GScipOutput* PROTOBUF_NONNULL _internal_mutable_gscip_output();
 
  public:
  // .operations_research.math_opt.OsqpOutput osqp_output = 8;
  bool has_osqp_output() const;
  private:
  bool _internal_has_osqp_output() const;
 
  public:
  void clear_osqp_output() ;
  const ::operations_research::math_opt::OsqpOutput& osqp_output() const;
  [[nodiscard]] ::operations_research::math_opt::OsqpOutput* PROTOBUF_NULLABLE release_osqp_output();
  ::operations_research::math_opt::OsqpOutput* PROTOBUF_NONNULL mutable_osqp_output();
  void set_allocated_osqp_output(::operations_research::math_opt::OsqpOutput* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_osqp_output(::operations_research::math_opt::OsqpOutput* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::OsqpOutput* PROTOBUF_NULLABLE unsafe_arena_release_osqp_output();
 
  private:
  const ::operations_research::math_opt::OsqpOutput& _internal_osqp_output() const;
  ::operations_research::math_opt::OsqpOutput* PROTOBUF_NONNULL _internal_mutable_osqp_output();
 
  public:
  // .operations_research.math_opt.SolveResultProto.PdlpOutput pdlp_output = 9;
  bool has_pdlp_output() const;
  private:
  bool _internal_has_pdlp_output() const;
 
  public:
  void clear_pdlp_output() ;
  const ::operations_research::math_opt::SolveResultProto_PdlpOutput& pdlp_output() const;
  [[nodiscard]] ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NULLABLE release_pdlp_output();
  ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NONNULL mutable_pdlp_output();
  void set_allocated_pdlp_output(::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_pdlp_output(::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NULLABLE unsafe_arena_release_pdlp_output();
 
  private:
  const ::operations_research::math_opt::SolveResultProto_PdlpOutput& _internal_pdlp_output() const;
  ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NONNULL _internal_mutable_pdlp_output();
 
  public:
  void clear_solver_specific_output();
  SolverSpecificOutputCase solver_specific_output_case() const;
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.SolveResultProto)
 private:
  class _Internal;
  void set_has_gscip_output();
  void set_has_osqp_output();
  void set_has_pdlp_output();
  inline bool has_solver_specific_output() const;
  inline void clear_has_solver_specific_output();
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<3, 8,
                                   8, 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 SolveResultProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::operations_research::math_opt::SolutionProto > solutions_;
    ::google::protobuf::RepeatedPtrField< ::operations_research::math_opt::PrimalRayProto > primal_rays_;
    ::google::protobuf::RepeatedPtrField< ::operations_research::math_opt::DualRayProto > dual_rays_;
    ::operations_research::math_opt::TerminationProto* PROTOBUF_NULLABLE termination_;
    ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NULLABLE solve_stats_;
    union SolverSpecificOutputUnion {
      constexpr SolverSpecificOutputUnion() : _constinit_{} {}
      ::google::protobuf::internal::ConstantInitialized _constinit_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE gscip_output_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE osqp_output_;
      ::google::protobuf::Message* PROTOBUF_NULLABLE pdlp_output_;
    } solver_specific_output_;
    ::uint32_t _oneof_case_[1];
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fresult_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolveResultProto_class_data_;
 
// ===================================================================
 
 
 
 
// ===================================================================
 
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// ProblemStatusProto
 
// .operations_research.math_opt.FeasibilityStatusProto primal_status = 1;
inline void ProblemStatusProto::clear_primal_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.primal_status_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::operations_research::math_opt::FeasibilityStatusProto ProblemStatusProto::primal_status() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.ProblemStatusProto.primal_status)
  return _internal_primal_status();
}
inline void ProblemStatusProto::set_primal_status(::operations_research::math_opt::FeasibilityStatusProto value) {
  _internal_set_primal_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.ProblemStatusProto.primal_status)
}
inline ::operations_research::math_opt::FeasibilityStatusProto ProblemStatusProto::_internal_primal_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::FeasibilityStatusProto>(_impl_.primal_status_);
}
inline void ProblemStatusProto::_internal_set_primal_status(::operations_research::math_opt::FeasibilityStatusProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.primal_status_ = value;
}
 
// .operations_research.math_opt.FeasibilityStatusProto dual_status = 2;
inline void ProblemStatusProto::clear_dual_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_status_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::operations_research::math_opt::FeasibilityStatusProto ProblemStatusProto::dual_status() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.ProblemStatusProto.dual_status)
  return _internal_dual_status();
}
inline void ProblemStatusProto::set_dual_status(::operations_research::math_opt::FeasibilityStatusProto value) {
  _internal_set_dual_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.ProblemStatusProto.dual_status)
}
inline ::operations_research::math_opt::FeasibilityStatusProto ProblemStatusProto::_internal_dual_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::FeasibilityStatusProto>(_impl_.dual_status_);
}
inline void ProblemStatusProto::_internal_set_dual_status(::operations_research::math_opt::FeasibilityStatusProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_status_ = value;
}
 
// bool primal_or_dual_infeasible = 3;
inline void ProblemStatusProto::clear_primal_or_dual_infeasible() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.primal_or_dual_infeasible_ = false;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline bool ProblemStatusProto::primal_or_dual_infeasible() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.ProblemStatusProto.primal_or_dual_infeasible)
  return _internal_primal_or_dual_infeasible();
}
inline void ProblemStatusProto::set_primal_or_dual_infeasible(bool value) {
  _internal_set_primal_or_dual_infeasible(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.ProblemStatusProto.primal_or_dual_infeasible)
}
inline bool ProblemStatusProto::_internal_primal_or_dual_infeasible() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.primal_or_dual_infeasible_;
}
inline void ProblemStatusProto::_internal_set_primal_or_dual_infeasible(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.primal_or_dual_infeasible_ = value;
}
 
// -------------------------------------------------------------------
 
// SolveStatsProto
 
// .google.protobuf.Duration solve_time = 1;
inline bool SolveStatsProto::has_solve_time() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.solve_time_ != nullptr);
  return value;
}
inline const ::google::protobuf::Duration& SolveStatsProto::_internal_solve_time() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::google::protobuf::Duration* p = _impl_.solve_time_;
  return p != nullptr ? *p : reinterpret_cast<const ::google::protobuf::Duration&>(::google::protobuf::_Duration_default_instance_);
}
inline const ::google::protobuf::Duration& SolveStatsProto::solve_time() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveStatsProto.solve_time)
  return _internal_solve_time();
}
inline void SolveStatsProto::unsafe_arena_set_allocated_solve_time(
    ::google::protobuf::Duration* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.solve_time_);
  }
  _impl_.solve_time_ = 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.SolveStatsProto.solve_time)
}
inline ::google::protobuf::Duration* PROTOBUF_NULLABLE SolveStatsProto::release_solve_time() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Duration* released = _impl_.solve_time_;
  _impl_.solve_time_ = 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 SolveStatsProto::unsafe_arena_release_solve_time() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveStatsProto.solve_time)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Duration* temp = _impl_.solve_time_;
  _impl_.solve_time_ = nullptr;
  return temp;
}
inline ::google::protobuf::Duration* PROTOBUF_NONNULL SolveStatsProto::_internal_mutable_solve_time() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.solve_time_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::google::protobuf::Duration>(GetArena());
    _impl_.solve_time_ = reinterpret_cast<::google::protobuf::Duration*>(p);
  }
  return _impl_.solve_time_;
}
inline ::google::protobuf::Duration* PROTOBUF_NONNULL SolveStatsProto::mutable_solve_time()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::google::protobuf::Duration* _msg = _internal_mutable_solve_time();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveStatsProto.solve_time)
  return _msg;
}
inline void SolveStatsProto::set_allocated_solve_time(::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_.solve_time_);
  }
 
  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_.solve_time_ = reinterpret_cast<::google::protobuf::Duration*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveStatsProto.solve_time)
}
 
// double best_primal_bound = 2 [deprecated = true];
inline void SolveStatsProto::clear_best_primal_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.best_primal_bound_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline double SolveStatsProto::best_primal_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveStatsProto.best_primal_bound)
  return _internal_best_primal_bound();
}
inline void SolveStatsProto::set_best_primal_bound(double value) {
  _internal_set_best_primal_bound(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveStatsProto.best_primal_bound)
}
inline double SolveStatsProto::_internal_best_primal_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.best_primal_bound_;
}
inline void SolveStatsProto::_internal_set_best_primal_bound(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.best_primal_bound_ = value;
}
 
// double best_dual_bound = 3 [deprecated = true];
inline void SolveStatsProto::clear_best_dual_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.best_dual_bound_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
inline double SolveStatsProto::best_dual_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveStatsProto.best_dual_bound)
  return _internal_best_dual_bound();
}
inline void SolveStatsProto::set_best_dual_bound(double value) {
  _internal_set_best_dual_bound(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveStatsProto.best_dual_bound)
}
inline double SolveStatsProto::_internal_best_dual_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.best_dual_bound_;
}
inline void SolveStatsProto::_internal_set_best_dual_bound(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.best_dual_bound_ = value;
}
 
// .operations_research.math_opt.ProblemStatusProto problem_status = 4 [deprecated = true];
inline bool SolveStatsProto::has_problem_status() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.problem_status_ != nullptr);
  return value;
}
inline void SolveStatsProto::clear_problem_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.problem_status_ != nullptr) _impl_.problem_status_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::operations_research::math_opt::ProblemStatusProto& SolveStatsProto::_internal_problem_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::ProblemStatusProto* p = _impl_.problem_status_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::ProblemStatusProto&>(::operations_research::math_opt::_ProblemStatusProto_default_instance_);
}
inline const ::operations_research::math_opt::ProblemStatusProto& SolveStatsProto::problem_status() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveStatsProto.problem_status)
  return _internal_problem_status();
}
inline void SolveStatsProto::unsafe_arena_set_allocated_problem_status(
    ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.problem_status_);
  }
  _impl_.problem_status_ = reinterpret_cast<::operations_research::math_opt::ProblemStatusProto*>(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.SolveStatsProto.problem_status)
}
inline ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE SolveStatsProto::release_problem_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::ProblemStatusProto* released = _impl_.problem_status_;
  _impl_.problem_status_ = 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::ProblemStatusProto* PROTOBUF_NULLABLE SolveStatsProto::unsafe_arena_release_problem_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveStatsProto.problem_status)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::ProblemStatusProto* temp = _impl_.problem_status_;
  _impl_.problem_status_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NONNULL SolveStatsProto::_internal_mutable_problem_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.problem_status_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::ProblemStatusProto>(GetArena());
    _impl_.problem_status_ = reinterpret_cast<::operations_research::math_opt::ProblemStatusProto*>(p);
  }
  return _impl_.problem_status_;
}
inline ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NONNULL SolveStatsProto::mutable_problem_status()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::ProblemStatusProto* _msg = _internal_mutable_problem_status();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveStatsProto.problem_status)
  return _msg;
}
inline void SolveStatsProto::set_allocated_problem_status(::operations_research::math_opt::ProblemStatusProto* 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_.problem_status_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = 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_.problem_status_ = reinterpret_cast<::operations_research::math_opt::ProblemStatusProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveStatsProto.problem_status)
}
 
// int64 simplex_iterations = 5;
inline void SolveStatsProto::clear_simplex_iterations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.simplex_iterations_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000010U);
}
inline ::int64_t SolveStatsProto::simplex_iterations() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveStatsProto.simplex_iterations)
  return _internal_simplex_iterations();
}
inline void SolveStatsProto::set_simplex_iterations(::int64_t value) {
  _internal_set_simplex_iterations(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveStatsProto.simplex_iterations)
}
inline ::int64_t SolveStatsProto::_internal_simplex_iterations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.simplex_iterations_;
}
inline void SolveStatsProto::_internal_set_simplex_iterations(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.simplex_iterations_ = value;
}
 
// int64 barrier_iterations = 6;
inline void SolveStatsProto::clear_barrier_iterations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.barrier_iterations_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000020U);
}
inline ::int64_t SolveStatsProto::barrier_iterations() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveStatsProto.barrier_iterations)
  return _internal_barrier_iterations();
}
inline void SolveStatsProto::set_barrier_iterations(::int64_t value) {
  _internal_set_barrier_iterations(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveStatsProto.barrier_iterations)
}
inline ::int64_t SolveStatsProto::_internal_barrier_iterations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.barrier_iterations_;
}
inline void SolveStatsProto::_internal_set_barrier_iterations(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.barrier_iterations_ = value;
}
 
// int64 first_order_iterations = 8;
inline void SolveStatsProto::clear_first_order_iterations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.first_order_iterations_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000080U);
}
inline ::int64_t SolveStatsProto::first_order_iterations() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveStatsProto.first_order_iterations)
  return _internal_first_order_iterations();
}
inline void SolveStatsProto::set_first_order_iterations(::int64_t value) {
  _internal_set_first_order_iterations(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveStatsProto.first_order_iterations)
}
inline ::int64_t SolveStatsProto::_internal_first_order_iterations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.first_order_iterations_;
}
inline void SolveStatsProto::_internal_set_first_order_iterations(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.first_order_iterations_ = value;
}
 
// int64 node_count = 7;
inline void SolveStatsProto::clear_node_count() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_count_ = ::int64_t{0};
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000040U);
}
inline ::int64_t SolveStatsProto::node_count() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveStatsProto.node_count)
  return _internal_node_count();
}
inline void SolveStatsProto::set_node_count(::int64_t value) {
  _internal_set_node_count(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SolveStatsProto.node_count)
}
inline ::int64_t SolveStatsProto::_internal_node_count() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.node_count_;
}
inline void SolveStatsProto::_internal_set_node_count(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.node_count_ = value;
}
 
// -------------------------------------------------------------------
 
// ObjectiveBoundsProto
 
// double primal_bound = 2;
inline void ObjectiveBoundsProto::clear_primal_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.primal_bound_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline double ObjectiveBoundsProto::primal_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.ObjectiveBoundsProto.primal_bound)
  return _internal_primal_bound();
}
inline void ObjectiveBoundsProto::set_primal_bound(double value) {
  _internal_set_primal_bound(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.ObjectiveBoundsProto.primal_bound)
}
inline double ObjectiveBoundsProto::_internal_primal_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.primal_bound_;
}
inline void ObjectiveBoundsProto::_internal_set_primal_bound(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.primal_bound_ = value;
}
 
// double dual_bound = 3;
inline void ObjectiveBoundsProto::clear_dual_bound() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_bound_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline double ObjectiveBoundsProto::dual_bound() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.ObjectiveBoundsProto.dual_bound)
  return _internal_dual_bound();
}
inline void ObjectiveBoundsProto::set_dual_bound(double value) {
  _internal_set_dual_bound(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.ObjectiveBoundsProto.dual_bound)
}
inline double ObjectiveBoundsProto::_internal_dual_bound() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dual_bound_;
}
inline void ObjectiveBoundsProto::_internal_set_dual_bound(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.dual_bound_ = value;
}
 
// -------------------------------------------------------------------
 
// TerminationProto
 
// .operations_research.math_opt.TerminationReasonProto reason = 1;
inline void TerminationProto::clear_reason() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.reason_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
inline ::operations_research::math_opt::TerminationReasonProto TerminationProto::reason() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.TerminationProto.reason)
  return _internal_reason();
}
inline void TerminationProto::set_reason(::operations_research::math_opt::TerminationReasonProto value) {
  _internal_set_reason(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.TerminationProto.reason)
}
inline ::operations_research::math_opt::TerminationReasonProto TerminationProto::_internal_reason() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::TerminationReasonProto>(_impl_.reason_);
}
inline void TerminationProto::_internal_set_reason(::operations_research::math_opt::TerminationReasonProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.reason_ = value;
}
 
// .operations_research.math_opt.LimitProto limit = 2;
inline void TerminationProto::clear_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.limit_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000010U);
}
inline ::operations_research::math_opt::LimitProto TerminationProto::limit() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.TerminationProto.limit)
  return _internal_limit();
}
inline void TerminationProto::set_limit(::operations_research::math_opt::LimitProto value) {
  _internal_set_limit(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.TerminationProto.limit)
}
inline ::operations_research::math_opt::LimitProto TerminationProto::_internal_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::LimitProto>(_impl_.limit_);
}
inline void TerminationProto::_internal_set_limit(::operations_research::math_opt::LimitProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.limit_ = value;
}
 
// string detail = 3;
inline void TerminationProto::clear_detail() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.detail_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::std::string& TerminationProto::detail() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.TerminationProto.detail)
  return _internal_detail();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TerminationProto::set_detail(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.detail_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:operations_research.math_opt.TerminationProto.detail)
}
inline ::std::string* PROTOBUF_NONNULL TerminationProto::mutable_detail()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_detail();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.TerminationProto.detail)
  return _s;
}
inline const ::std::string& TerminationProto::_internal_detail() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.detail_.Get();
}
inline void TerminationProto::_internal_set_detail(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.detail_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TerminationProto::_internal_mutable_detail() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.detail_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TerminationProto::release_detail() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.TerminationProto.detail)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.detail_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.detail_.Set("", GetArena());
  }
  return released;
}
inline void TerminationProto::set_allocated_detail(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.detail_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.detail_.IsDefault()) {
    _impl_.detail_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.TerminationProto.detail)
}
 
// .operations_research.math_opt.ProblemStatusProto problem_status = 4;
inline bool TerminationProto::has_problem_status() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.problem_status_ != nullptr);
  return value;
}
inline void TerminationProto::clear_problem_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.problem_status_ != nullptr) _impl_.problem_status_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::operations_research::math_opt::ProblemStatusProto& TerminationProto::_internal_problem_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::ProblemStatusProto* p = _impl_.problem_status_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::ProblemStatusProto&>(::operations_research::math_opt::_ProblemStatusProto_default_instance_);
}
inline const ::operations_research::math_opt::ProblemStatusProto& TerminationProto::problem_status() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.TerminationProto.problem_status)
  return _internal_problem_status();
}
inline void TerminationProto::unsafe_arena_set_allocated_problem_status(
    ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.problem_status_);
  }
  _impl_.problem_status_ = reinterpret_cast<::operations_research::math_opt::ProblemStatusProto*>(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.TerminationProto.problem_status)
}
inline ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NULLABLE TerminationProto::release_problem_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::ProblemStatusProto* released = _impl_.problem_status_;
  _impl_.problem_status_ = 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::ProblemStatusProto* PROTOBUF_NULLABLE TerminationProto::unsafe_arena_release_problem_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.TerminationProto.problem_status)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::ProblemStatusProto* temp = _impl_.problem_status_;
  _impl_.problem_status_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NONNULL TerminationProto::_internal_mutable_problem_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.problem_status_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::ProblemStatusProto>(GetArena());
    _impl_.problem_status_ = reinterpret_cast<::operations_research::math_opt::ProblemStatusProto*>(p);
  }
  return _impl_.problem_status_;
}
inline ::operations_research::math_opt::ProblemStatusProto* PROTOBUF_NONNULL TerminationProto::mutable_problem_status()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::ProblemStatusProto* _msg = _internal_mutable_problem_status();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.TerminationProto.problem_status)
  return _msg;
}
inline void TerminationProto::set_allocated_problem_status(::operations_research::math_opt::ProblemStatusProto* 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_.problem_status_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = 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_.problem_status_ = reinterpret_cast<::operations_research::math_opt::ProblemStatusProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.TerminationProto.problem_status)
}
 
// .operations_research.math_opt.ObjectiveBoundsProto objective_bounds = 5;
inline bool TerminationProto::has_objective_bounds() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.objective_bounds_ != nullptr);
  return value;
}
inline void TerminationProto::clear_objective_bounds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.objective_bounds_ != nullptr) _impl_.objective_bounds_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline const ::operations_research::math_opt::ObjectiveBoundsProto& TerminationProto::_internal_objective_bounds() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::ObjectiveBoundsProto* p = _impl_.objective_bounds_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::ObjectiveBoundsProto&>(::operations_research::math_opt::_ObjectiveBoundsProto_default_instance_);
}
inline const ::operations_research::math_opt::ObjectiveBoundsProto& TerminationProto::objective_bounds() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.TerminationProto.objective_bounds)
  return _internal_objective_bounds();
}
inline void TerminationProto::unsafe_arena_set_allocated_objective_bounds(
    ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.objective_bounds_);
  }
  _impl_.objective_bounds_ = reinterpret_cast<::operations_research::math_opt::ObjectiveBoundsProto*>(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.TerminationProto.objective_bounds)
}
inline ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NULLABLE TerminationProto::release_objective_bounds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::ObjectiveBoundsProto* released = _impl_.objective_bounds_;
  _impl_.objective_bounds_ = 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::ObjectiveBoundsProto* PROTOBUF_NULLABLE TerminationProto::unsafe_arena_release_objective_bounds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.TerminationProto.objective_bounds)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::ObjectiveBoundsProto* temp = _impl_.objective_bounds_;
  _impl_.objective_bounds_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NONNULL TerminationProto::_internal_mutable_objective_bounds() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.objective_bounds_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::ObjectiveBoundsProto>(GetArena());
    _impl_.objective_bounds_ = reinterpret_cast<::operations_research::math_opt::ObjectiveBoundsProto*>(p);
  }
  return _impl_.objective_bounds_;
}
inline ::operations_research::math_opt::ObjectiveBoundsProto* PROTOBUF_NONNULL TerminationProto::mutable_objective_bounds()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::ObjectiveBoundsProto* _msg = _internal_mutable_objective_bounds();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.TerminationProto.objective_bounds)
  return _msg;
}
inline void TerminationProto::set_allocated_objective_bounds(::operations_research::math_opt::ObjectiveBoundsProto* 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_.objective_bounds_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = 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_.objective_bounds_ = reinterpret_cast<::operations_research::math_opt::ObjectiveBoundsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.TerminationProto.objective_bounds)
}
 
// -------------------------------------------------------------------
 
// SolveResultProto_PdlpOutput
 
// .operations_research.pdlp.ConvergenceInformation convergence_information = 1;
inline bool SolveResultProto_PdlpOutput::has_convergence_information() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.convergence_information_ != nullptr);
  return value;
}
inline const ::operations_research::pdlp::ConvergenceInformation& SolveResultProto_PdlpOutput::_internal_convergence_information() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::pdlp::ConvergenceInformation* p = _impl_.convergence_information_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::pdlp::ConvergenceInformation&>(::operations_research::pdlp::_ConvergenceInformation_default_instance_);
}
inline const ::operations_research::pdlp::ConvergenceInformation& SolveResultProto_PdlpOutput::convergence_information() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.PdlpOutput.convergence_information)
  return _internal_convergence_information();
}
inline void SolveResultProto_PdlpOutput::unsafe_arena_set_allocated_convergence_information(
    ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.convergence_information_);
  }
  _impl_.convergence_information_ = reinterpret_cast<::operations_research::pdlp::ConvergenceInformation*>(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.SolveResultProto.PdlpOutput.convergence_information)
}
inline ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NULLABLE SolveResultProto_PdlpOutput::release_convergence_information() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::pdlp::ConvergenceInformation* released = _impl_.convergence_information_;
  _impl_.convergence_information_ = 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::ConvergenceInformation* PROTOBUF_NULLABLE SolveResultProto_PdlpOutput::unsafe_arena_release_convergence_information() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveResultProto.PdlpOutput.convergence_information)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::pdlp::ConvergenceInformation* temp = _impl_.convergence_information_;
  _impl_.convergence_information_ = nullptr;
  return temp;
}
inline ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NONNULL SolveResultProto_PdlpOutput::_internal_mutable_convergence_information() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.convergence_information_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::pdlp::ConvergenceInformation>(GetArena());
    _impl_.convergence_information_ = reinterpret_cast<::operations_research::pdlp::ConvergenceInformation*>(p);
  }
  return _impl_.convergence_information_;
}
inline ::operations_research::pdlp::ConvergenceInformation* PROTOBUF_NONNULL SolveResultProto_PdlpOutput::mutable_convergence_information()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::pdlp::ConvergenceInformation* _msg = _internal_mutable_convergence_information();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.PdlpOutput.convergence_information)
  return _msg;
}
inline void SolveResultProto_PdlpOutput::set_allocated_convergence_information(::operations_research::pdlp::ConvergenceInformation* 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_.convergence_information_);
  }
 
  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_.convergence_information_ = reinterpret_cast<::operations_research::pdlp::ConvergenceInformation*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveResultProto.PdlpOutput.convergence_information)
}
 
// -------------------------------------------------------------------
 
// SolveResultProto
 
// .operations_research.math_opt.TerminationProto termination = 2;
inline bool SolveResultProto::has_termination() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.termination_ != nullptr);
  return value;
}
inline void SolveResultProto::clear_termination() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.termination_ != nullptr) _impl_.termination_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
inline const ::operations_research::math_opt::TerminationProto& SolveResultProto::_internal_termination() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::TerminationProto* p = _impl_.termination_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::TerminationProto&>(::operations_research::math_opt::_TerminationProto_default_instance_);
}
inline const ::operations_research::math_opt::TerminationProto& SolveResultProto::termination() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.termination)
  return _internal_termination();
}
inline void SolveResultProto::unsafe_arena_set_allocated_termination(
    ::operations_research::math_opt::TerminationProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.termination_);
  }
  _impl_.termination_ = reinterpret_cast<::operations_research::math_opt::TerminationProto*>(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.SolveResultProto.termination)
}
inline ::operations_research::math_opt::TerminationProto* PROTOBUF_NULLABLE SolveResultProto::release_termination() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::operations_research::math_opt::TerminationProto* released = _impl_.termination_;
  _impl_.termination_ = 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::TerminationProto* PROTOBUF_NULLABLE SolveResultProto::unsafe_arena_release_termination() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveResultProto.termination)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::operations_research::math_opt::TerminationProto* temp = _impl_.termination_;
  _impl_.termination_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::TerminationProto* PROTOBUF_NONNULL SolveResultProto::_internal_mutable_termination() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.termination_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::TerminationProto>(GetArena());
    _impl_.termination_ = reinterpret_cast<::operations_research::math_opt::TerminationProto*>(p);
  }
  return _impl_.termination_;
}
inline ::operations_research::math_opt::TerminationProto* PROTOBUF_NONNULL SolveResultProto::mutable_termination()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::operations_research::math_opt::TerminationProto* _msg = _internal_mutable_termination();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.termination)
  return _msg;
}
inline void SolveResultProto::set_allocated_termination(::operations_research::math_opt::TerminationProto* 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_.termination_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = 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_.termination_ = reinterpret_cast<::operations_research::math_opt::TerminationProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveResultProto.termination)
}
 
// repeated .operations_research.math_opt.SolutionProto solutions = 3;
inline int SolveResultProto::_internal_solutions_size() const {
  return _internal_solutions().size();
}
inline int SolveResultProto::solutions_size() const {
  return _internal_solutions_size();
}
inline ::operations_research::math_opt::SolutionProto* PROTOBUF_NONNULL SolveResultProto::mutable_solutions(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.solutions)
  return _internal_mutable_solutions()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::SolutionProto>* PROTOBUF_NONNULL SolveResultProto::mutable_solutions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.math_opt.SolveResultProto.solutions)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_solutions();
}
inline const ::operations_research::math_opt::SolutionProto& SolveResultProto::solutions(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.solutions)
  return _internal_solutions().Get(index);
}
inline ::operations_research::math_opt::SolutionProto* PROTOBUF_NONNULL SolveResultProto::add_solutions()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::operations_research::math_opt::SolutionProto* _add =
      _internal_mutable_solutions()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:operations_research.math_opt.SolveResultProto.solutions)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::SolutionProto>& SolveResultProto::solutions() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.math_opt.SolveResultProto.solutions)
  return _internal_solutions();
}
inline const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::SolutionProto>&
SolveResultProto::_internal_solutions() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.solutions_;
}
inline ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::SolutionProto>* PROTOBUF_NONNULL
SolveResultProto::_internal_mutable_solutions() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.solutions_;
}
 
// repeated .operations_research.math_opt.PrimalRayProto primal_rays = 4;
inline int SolveResultProto::_internal_primal_rays_size() const {
  return _internal_primal_rays().size();
}
inline int SolveResultProto::primal_rays_size() const {
  return _internal_primal_rays_size();
}
inline ::operations_research::math_opt::PrimalRayProto* PROTOBUF_NONNULL SolveResultProto::mutable_primal_rays(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.primal_rays)
  return _internal_mutable_primal_rays()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::PrimalRayProto>* PROTOBUF_NONNULL SolveResultProto::mutable_primal_rays()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.math_opt.SolveResultProto.primal_rays)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_primal_rays();
}
inline const ::operations_research::math_opt::PrimalRayProto& SolveResultProto::primal_rays(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.primal_rays)
  return _internal_primal_rays().Get(index);
}
inline ::operations_research::math_opt::PrimalRayProto* PROTOBUF_NONNULL SolveResultProto::add_primal_rays()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::operations_research::math_opt::PrimalRayProto* _add =
      _internal_mutable_primal_rays()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:operations_research.math_opt.SolveResultProto.primal_rays)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::PrimalRayProto>& SolveResultProto::primal_rays() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.math_opt.SolveResultProto.primal_rays)
  return _internal_primal_rays();
}
inline const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::PrimalRayProto>&
SolveResultProto::_internal_primal_rays() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.primal_rays_;
}
inline ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::PrimalRayProto>* PROTOBUF_NONNULL
SolveResultProto::_internal_mutable_primal_rays() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.primal_rays_;
}
 
// repeated .operations_research.math_opt.DualRayProto dual_rays = 5;
inline int SolveResultProto::_internal_dual_rays_size() const {
  return _internal_dual_rays().size();
}
inline int SolveResultProto::dual_rays_size() const {
  return _internal_dual_rays_size();
}
inline ::operations_research::math_opt::DualRayProto* PROTOBUF_NONNULL SolveResultProto::mutable_dual_rays(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.dual_rays)
  return _internal_mutable_dual_rays()->Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::DualRayProto>* PROTOBUF_NONNULL SolveResultProto::mutable_dual_rays()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.math_opt.SolveResultProto.dual_rays)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_dual_rays();
}
inline const ::operations_research::math_opt::DualRayProto& SolveResultProto::dual_rays(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.dual_rays)
  return _internal_dual_rays().Get(index);
}
inline ::operations_research::math_opt::DualRayProto* PROTOBUF_NONNULL SolveResultProto::add_dual_rays()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::operations_research::math_opt::DualRayProto* _add =
      _internal_mutable_dual_rays()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:operations_research.math_opt.SolveResultProto.dual_rays)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::DualRayProto>& SolveResultProto::dual_rays() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.math_opt.SolveResultProto.dual_rays)
  return _internal_dual_rays();
}
inline const ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::DualRayProto>&
SolveResultProto::_internal_dual_rays() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.dual_rays_;
}
inline ::google::protobuf::RepeatedPtrField<::operations_research::math_opt::DualRayProto>* PROTOBUF_NONNULL
SolveResultProto::_internal_mutable_dual_rays() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.dual_rays_;
}
 
// .operations_research.math_opt.SolveStatsProto solve_stats = 6;
inline bool SolveResultProto::has_solve_stats() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.solve_stats_ != nullptr);
  return value;
}
inline void SolveResultProto::clear_solve_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.solve_stats_ != nullptr) _impl_.solve_stats_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000010U);
}
inline const ::operations_research::math_opt::SolveStatsProto& SolveResultProto::_internal_solve_stats() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SolveStatsProto* p = _impl_.solve_stats_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SolveStatsProto&>(::operations_research::math_opt::_SolveStatsProto_default_instance_);
}
inline const ::operations_research::math_opt::SolveStatsProto& SolveResultProto::solve_stats() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.solve_stats)
  return _internal_solve_stats();
}
inline void SolveResultProto::unsafe_arena_set_allocated_solve_stats(
    ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.solve_stats_);
  }
  _impl_.solve_stats_ = reinterpret_cast<::operations_research::math_opt::SolveStatsProto*>(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.SolveResultProto.solve_stats)
}
inline ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NULLABLE SolveResultProto::release_solve_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::operations_research::math_opt::SolveStatsProto* released = _impl_.solve_stats_;
  _impl_.solve_stats_ = 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::SolveStatsProto* PROTOBUF_NULLABLE SolveResultProto::unsafe_arena_release_solve_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveResultProto.solve_stats)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::operations_research::math_opt::SolveStatsProto* temp = _impl_.solve_stats_;
  _impl_.solve_stats_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NONNULL SolveResultProto::_internal_mutable_solve_stats() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.solve_stats_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SolveStatsProto>(GetArena());
    _impl_.solve_stats_ = reinterpret_cast<::operations_research::math_opt::SolveStatsProto*>(p);
  }
  return _impl_.solve_stats_;
}
inline ::operations_research::math_opt::SolveStatsProto* PROTOBUF_NONNULL SolveResultProto::mutable_solve_stats()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::operations_research::math_opt::SolveStatsProto* _msg = _internal_mutable_solve_stats();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.solve_stats)
  return _msg;
}
inline void SolveResultProto::set_allocated_solve_stats(::operations_research::math_opt::SolveStatsProto* 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_.solve_stats_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = 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_.solve_stats_ = reinterpret_cast<::operations_research::math_opt::SolveStatsProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolveResultProto.solve_stats)
}
 
// .operations_research.GScipOutput gscip_output = 7;
inline bool SolveResultProto::has_gscip_output() const {
  return solver_specific_output_case() == kGscipOutput;
}
inline bool SolveResultProto::_internal_has_gscip_output() const {
  return solver_specific_output_case() == kGscipOutput;
}
inline void SolveResultProto::set_has_gscip_output() {
  _impl_._oneof_case_[0] = kGscipOutput;
}
inline ::operations_research::GScipOutput* PROTOBUF_NULLABLE SolveResultProto::release_gscip_output() {
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveResultProto.gscip_output)
  if (solver_specific_output_case() == kGscipOutput) {
    clear_has_solver_specific_output();
    auto* temp = reinterpret_cast<::operations_research::GScipOutput*>(_impl_.solver_specific_output_.gscip_output_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.solver_specific_output_.gscip_output_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::GScipOutput& SolveResultProto::_internal_gscip_output() const {
  return solver_specific_output_case() == kGscipOutput ? static_cast<const ::operations_research::GScipOutput&>(*reinterpret_cast<::operations_research::GScipOutput*>(_impl_.solver_specific_output_.gscip_output_))
                     : reinterpret_cast<const ::operations_research::GScipOutput&>(::operations_research::_GScipOutput_default_instance_);
}
inline const ::operations_research::GScipOutput& SolveResultProto::gscip_output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.gscip_output)
  return _internal_gscip_output();
}
inline ::operations_research::GScipOutput* PROTOBUF_NULLABLE SolveResultProto::unsafe_arena_release_gscip_output() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.math_opt.SolveResultProto.gscip_output)
  if (solver_specific_output_case() == kGscipOutput) {
    clear_has_solver_specific_output();
    auto* temp = reinterpret_cast<::operations_research::GScipOutput*>(_impl_.solver_specific_output_.gscip_output_);
    _impl_.solver_specific_output_.gscip_output_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SolveResultProto::unsafe_arena_set_allocated_gscip_output(
    ::operations_research::GScipOutput* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_solver_specific_output();
  if (value) {
    set_has_gscip_output();
    _impl_.solver_specific_output_.gscip_output_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveResultProto.gscip_output)
}
inline ::operations_research::GScipOutput* PROTOBUF_NONNULL SolveResultProto::_internal_mutable_gscip_output() {
  if (solver_specific_output_case() != kGscipOutput) {
    clear_solver_specific_output();
    set_has_gscip_output();
    _impl_.solver_specific_output_.gscip_output_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::operations_research::GScipOutput>(GetArena()));
  }
  return reinterpret_cast<::operations_research::GScipOutput*>(_impl_.solver_specific_output_.gscip_output_);
}
inline ::operations_research::GScipOutput* PROTOBUF_NONNULL SolveResultProto::mutable_gscip_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::operations_research::GScipOutput* _msg = _internal_mutable_gscip_output();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.gscip_output)
  return _msg;
}
 
// .operations_research.math_opt.OsqpOutput osqp_output = 8;
inline bool SolveResultProto::has_osqp_output() const {
  return solver_specific_output_case() == kOsqpOutput;
}
inline bool SolveResultProto::_internal_has_osqp_output() const {
  return solver_specific_output_case() == kOsqpOutput;
}
inline void SolveResultProto::set_has_osqp_output() {
  _impl_._oneof_case_[0] = kOsqpOutput;
}
inline ::operations_research::math_opt::OsqpOutput* PROTOBUF_NULLABLE SolveResultProto::release_osqp_output() {
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveResultProto.osqp_output)
  if (solver_specific_output_case() == kOsqpOutput) {
    clear_has_solver_specific_output();
    auto* temp = reinterpret_cast<::operations_research::math_opt::OsqpOutput*>(_impl_.solver_specific_output_.osqp_output_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.solver_specific_output_.osqp_output_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::math_opt::OsqpOutput& SolveResultProto::_internal_osqp_output() const {
  return solver_specific_output_case() == kOsqpOutput ? static_cast<const ::operations_research::math_opt::OsqpOutput&>(*reinterpret_cast<::operations_research::math_opt::OsqpOutput*>(_impl_.solver_specific_output_.osqp_output_))
                     : reinterpret_cast<const ::operations_research::math_opt::OsqpOutput&>(::operations_research::math_opt::_OsqpOutput_default_instance_);
}
inline const ::operations_research::math_opt::OsqpOutput& SolveResultProto::osqp_output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.osqp_output)
  return _internal_osqp_output();
}
inline ::operations_research::math_opt::OsqpOutput* PROTOBUF_NULLABLE SolveResultProto::unsafe_arena_release_osqp_output() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.math_opt.SolveResultProto.osqp_output)
  if (solver_specific_output_case() == kOsqpOutput) {
    clear_has_solver_specific_output();
    auto* temp = reinterpret_cast<::operations_research::math_opt::OsqpOutput*>(_impl_.solver_specific_output_.osqp_output_);
    _impl_.solver_specific_output_.osqp_output_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SolveResultProto::unsafe_arena_set_allocated_osqp_output(
    ::operations_research::math_opt::OsqpOutput* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_solver_specific_output();
  if (value) {
    set_has_osqp_output();
    _impl_.solver_specific_output_.osqp_output_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveResultProto.osqp_output)
}
inline ::operations_research::math_opt::OsqpOutput* PROTOBUF_NONNULL SolveResultProto::_internal_mutable_osqp_output() {
  if (solver_specific_output_case() != kOsqpOutput) {
    clear_solver_specific_output();
    set_has_osqp_output();
    _impl_.solver_specific_output_.osqp_output_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::OsqpOutput>(GetArena()));
  }
  return reinterpret_cast<::operations_research::math_opt::OsqpOutput*>(_impl_.solver_specific_output_.osqp_output_);
}
inline ::operations_research::math_opt::OsqpOutput* PROTOBUF_NONNULL SolveResultProto::mutable_osqp_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::operations_research::math_opt::OsqpOutput* _msg = _internal_mutable_osqp_output();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.osqp_output)
  return _msg;
}
 
// .operations_research.math_opt.SolveResultProto.PdlpOutput pdlp_output = 9;
inline bool SolveResultProto::has_pdlp_output() const {
  return solver_specific_output_case() == kPdlpOutput;
}
inline bool SolveResultProto::_internal_has_pdlp_output() const {
  return solver_specific_output_case() == kPdlpOutput;
}
inline void SolveResultProto::set_has_pdlp_output() {
  _impl_._oneof_case_[0] = kPdlpOutput;
}
inline void SolveResultProto::clear_pdlp_output() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (solver_specific_output_case() == kPdlpOutput) {
    if (GetArena() == nullptr) {
      delete _impl_.solver_specific_output_.pdlp_output_;
    } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
      ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.solver_specific_output_.pdlp_output_);
    }
    clear_has_solver_specific_output();
  }
}
inline ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NULLABLE SolveResultProto::release_pdlp_output() {
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolveResultProto.pdlp_output)
  if (solver_specific_output_case() == kPdlpOutput) {
    clear_has_solver_specific_output();
    auto* temp = reinterpret_cast<::operations_research::math_opt::SolveResultProto_PdlpOutput*>(_impl_.solver_specific_output_.pdlp_output_);
    if (GetArena() != nullptr) {
      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp);
    }
    _impl_.solver_specific_output_.pdlp_output_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::operations_research::math_opt::SolveResultProto_PdlpOutput& SolveResultProto::_internal_pdlp_output() const {
  return solver_specific_output_case() == kPdlpOutput ? static_cast<const ::operations_research::math_opt::SolveResultProto_PdlpOutput&>(*reinterpret_cast<::operations_research::math_opt::SolveResultProto_PdlpOutput*>(_impl_.solver_specific_output_.pdlp_output_))
                     : reinterpret_cast<const ::operations_research::math_opt::SolveResultProto_PdlpOutput&>(::operations_research::math_opt::_SolveResultProto_PdlpOutput_default_instance_);
}
inline const ::operations_research::math_opt::SolveResultProto_PdlpOutput& SolveResultProto::pdlp_output() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolveResultProto.pdlp_output)
  return _internal_pdlp_output();
}
inline ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NULLABLE SolveResultProto::unsafe_arena_release_pdlp_output() {
  // @@protoc_insertion_point(field_unsafe_arena_release:operations_research.math_opt.SolveResultProto.pdlp_output)
  if (solver_specific_output_case() == kPdlpOutput) {
    clear_has_solver_specific_output();
    auto* temp = reinterpret_cast<::operations_research::math_opt::SolveResultProto_PdlpOutput*>(_impl_.solver_specific_output_.pdlp_output_);
    _impl_.solver_specific_output_.pdlp_output_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void SolveResultProto::unsafe_arena_set_allocated_pdlp_output(
    ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NULLABLE value) {
  // We rely on the oneof clear method to free the earlier contents
  // of this oneof. We can directly use the pointer we're given to
  // set the new value.
  clear_solver_specific_output();
  if (value) {
    set_has_pdlp_output();
    _impl_.solver_specific_output_.pdlp_output_ = reinterpret_cast<::google::protobuf::Message*>(value);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:operations_research.math_opt.SolveResultProto.pdlp_output)
}
inline ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NONNULL SolveResultProto::_internal_mutable_pdlp_output() {
  if (solver_specific_output_case() != kPdlpOutput) {
    clear_solver_specific_output();
    set_has_pdlp_output();
    _impl_.solver_specific_output_.pdlp_output_ = reinterpret_cast<::google::protobuf::Message*>(
        ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SolveResultProto_PdlpOutput>(GetArena()));
  }
  return reinterpret_cast<::operations_research::math_opt::SolveResultProto_PdlpOutput*>(_impl_.solver_specific_output_.pdlp_output_);
}
inline ::operations_research::math_opt::SolveResultProto_PdlpOutput* PROTOBUF_NONNULL SolveResultProto::mutable_pdlp_output()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::operations_research::math_opt::SolveResultProto_PdlpOutput* _msg = _internal_mutable_pdlp_output();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolveResultProto.pdlp_output)
  return _msg;
}
 
inline bool SolveResultProto::has_solver_specific_output() const {
  return solver_specific_output_case() != SOLVER_SPECIFIC_OUTPUT_NOT_SET;
}
inline void SolveResultProto::clear_has_solver_specific_output() {
  _impl_._oneof_case_[0] = SOLVER_SPECIFIC_OUTPUT_NOT_SET;
}
inline SolveResultProto::SolverSpecificOutputCase SolveResultProto::solver_specific_output_case() const {
  return SolveResultProto::SolverSpecificOutputCase(_impl_._oneof_case_[0]);
}
#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::FeasibilityStatusProto> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::math_opt::FeasibilityStatusProto>() {
  return ::operations_research::math_opt::FeasibilityStatusProto_descriptor();
}
template <>
struct is_proto_enum<::operations_research::math_opt::TerminationReasonProto> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::math_opt::TerminationReasonProto>() {
  return ::operations_research::math_opt::TerminationReasonProto_descriptor();
}
template <>
struct is_proto_enum<::operations_research::math_opt::LimitProto> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::math_opt::LimitProto>() {
  return ::operations_research::math_opt::LimitProto_descriptor();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#include "google/protobuf/port_undef.inc"
 
#endif  // ortools_2fmath_5fopt_2fresult_2eproto_2epb_2eh