solution.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/solution.proto
// Protobuf C++ Version: 6.33.1
 
#ifndef ortools_2fmath_5fopt_2fsolution_2eproto_2epb_2eh
#define ortools_2fmath_5fopt_2fsolution_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/map.h"  // IWYU pragma: export
#include "google/protobuf/map_type_handler.h"  // IWYU pragma: export
#include "google/protobuf/map_entry.h"
#include "google/protobuf/map_field.h"
#include "google/protobuf/generated_enum_reflection.h"
#include "google/protobuf/unknown_field_set.h"
#include "ortools/math_opt/sparse_containers.pb.h"
// @@protoc_insertion_point(includes)
 
// Must be included last.
#include "google/protobuf/port_def.inc"
 
#define PROTOBUF_INTERNAL_EXPORT_ortools_2fmath_5fopt_2fsolution_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_2fsolution_2eproto {
  static const ::uint32_t offsets[];
};
extern "C" {
OR_PROTO_DLL extern const ::google::protobuf::internal::DescriptorTable descriptor_table_ortools_2fmath_5fopt_2fsolution_2eproto;
}  // extern "C"
namespace operations_research {
namespace math_opt {
enum BasisStatusProto : int;
OR_PROTO_DLL extern const uint32_t BasisStatusProto_internal_data_[];
enum SolutionStatusProto : int;
OR_PROTO_DLL extern const uint32_t SolutionStatusProto_internal_data_[];
class BasisProto;
struct BasisProtoDefaultTypeInternal;
OR_PROTO_DLL extern BasisProtoDefaultTypeInternal _BasisProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull BasisProto_class_data_;
class DualRayProto;
struct DualRayProtoDefaultTypeInternal;
OR_PROTO_DLL extern DualRayProtoDefaultTypeInternal _DualRayProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull DualRayProto_class_data_;
class DualSolutionProto;
struct DualSolutionProtoDefaultTypeInternal;
OR_PROTO_DLL extern DualSolutionProtoDefaultTypeInternal _DualSolutionProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull DualSolutionProto_class_data_;
class PrimalRayProto;
struct PrimalRayProtoDefaultTypeInternal;
OR_PROTO_DLL extern PrimalRayProtoDefaultTypeInternal _PrimalRayProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull PrimalRayProto_class_data_;
class PrimalSolutionProto;
struct PrimalSolutionProtoDefaultTypeInternal;
OR_PROTO_DLL extern PrimalSolutionProtoDefaultTypeInternal _PrimalSolutionProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull PrimalSolutionProto_class_data_;
class PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse;
struct PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUseDefaultTypeInternal;
OR_PROTO_DLL extern PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUseDefaultTypeInternal _PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse_class_data_;
class SolutionProto;
struct SolutionProtoDefaultTypeInternal;
OR_PROTO_DLL extern SolutionProtoDefaultTypeInternal _SolutionProto_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolutionProto_class_data_;
class SparseBasisStatusVector;
struct SparseBasisStatusVectorDefaultTypeInternal;
OR_PROTO_DLL extern SparseBasisStatusVectorDefaultTypeInternal _SparseBasisStatusVector_default_instance_;
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SparseBasisStatusVector_class_data_;
}  // namespace math_opt
}  // namespace operations_research
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::operations_research::math_opt::BasisStatusProto_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::math_opt::BasisStatusProto>;
template <>
internal::EnumTraitsT<::operations_research::math_opt::SolutionStatusProto_internal_data_>
    internal::EnumTraitsImpl::value<::operations_research::math_opt::SolutionStatusProto>;
}  // namespace protobuf
}  // namespace google
 
namespace operations_research {
namespace math_opt {
enum SolutionStatusProto : int {
  SOLUTION_STATUS_UNSPECIFIED = 0,
  SOLUTION_STATUS_UNDETERMINED = 1,
  SOLUTION_STATUS_FEASIBLE = 2,
  SOLUTION_STATUS_INFEASIBLE = 3,
  SolutionStatusProto_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  SolutionStatusProto_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};
 
OR_PROTO_DLL extern const uint32_t SolutionStatusProto_internal_data_[];
inline constexpr SolutionStatusProto SolutionStatusProto_MIN =
    static_cast<SolutionStatusProto>(0);
inline constexpr SolutionStatusProto SolutionStatusProto_MAX =
    static_cast<SolutionStatusProto>(3);
inline bool SolutionStatusProto_IsValid(int value) {
  return 0 <= value && value <= 3;
}
inline constexpr int SolutionStatusProto_ARRAYSIZE = 3 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL SolutionStatusProto_descriptor();
template <typename T>
const ::std::string& SolutionStatusProto_Name(T value) {
  static_assert(::std::is_same<T, SolutionStatusProto>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to SolutionStatusProto_Name().");
  return SolutionStatusProto_Name(static_cast<SolutionStatusProto>(value));
}
template <>
inline const ::std::string& SolutionStatusProto_Name(SolutionStatusProto value) {
  return ::google::protobuf::internal::NameOfDenseEnum<SolutionStatusProto_descriptor, 0, 3>(
      static_cast<int>(value));
}
inline bool SolutionStatusProto_Parse(
    ::absl::string_view name, SolutionStatusProto* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<SolutionStatusProto>(SolutionStatusProto_descriptor(), name,
                                           value);
}
enum BasisStatusProto : int {
  BASIS_STATUS_UNSPECIFIED = 0,
  BASIS_STATUS_FREE = 1,
  BASIS_STATUS_AT_LOWER_BOUND = 2,
  BASIS_STATUS_AT_UPPER_BOUND = 3,
  BASIS_STATUS_FIXED_VALUE = 4,
  BASIS_STATUS_BASIC = 5,
  BasisStatusProto_INT_MIN_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::min(),
  BasisStatusProto_INT_MAX_SENTINEL_DO_NOT_USE_ =
      ::std::numeric_limits<::int32_t>::max(),
};
 
OR_PROTO_DLL extern const uint32_t BasisStatusProto_internal_data_[];
inline constexpr BasisStatusProto BasisStatusProto_MIN =
    static_cast<BasisStatusProto>(0);
inline constexpr BasisStatusProto BasisStatusProto_MAX =
    static_cast<BasisStatusProto>(5);
inline bool BasisStatusProto_IsValid(int value) {
  return 0 <= value && value <= 5;
}
inline constexpr int BasisStatusProto_ARRAYSIZE = 5 + 1;
OR_PROTO_DLL const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL BasisStatusProto_descriptor();
template <typename T>
const ::std::string& BasisStatusProto_Name(T value) {
  static_assert(::std::is_same<T, BasisStatusProto>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to BasisStatusProto_Name().");
  return BasisStatusProto_Name(static_cast<BasisStatusProto>(value));
}
template <>
inline const ::std::string& BasisStatusProto_Name(BasisStatusProto value) {
  return ::google::protobuf::internal::NameOfDenseEnum<BasisStatusProto_descriptor, 0, 5>(
      static_cast<int>(value));
}
inline bool BasisStatusProto_Parse(
    ::absl::string_view name, BasisStatusProto* PROTOBUF_NONNULL value) {
  return ::google::protobuf::internal::ParseNamedEnum<BasisStatusProto>(BasisStatusProto_descriptor(), name,
                                           value);
}
 
// ===================================================================
 
 
// -------------------------------------------------------------------
 
class OR_PROTO_DLL SparseBasisStatusVector final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.SparseBasisStatusVector) */ {
 public:
  inline SparseBasisStatusVector() : SparseBasisStatusVector(nullptr) {}
  ~SparseBasisStatusVector() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SparseBasisStatusVector* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SparseBasisStatusVector));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR SparseBasisStatusVector(::google::protobuf::internal::ConstantInitialized);
 
  inline SparseBasisStatusVector(const SparseBasisStatusVector& from) : SparseBasisStatusVector(nullptr, from) {}
  inline SparseBasisStatusVector(SparseBasisStatusVector&& from) noexcept
      : SparseBasisStatusVector(nullptr, ::std::move(from)) {}
  inline SparseBasisStatusVector& operator=(const SparseBasisStatusVector& from) {
    CopyFrom(from);
    return *this;
  }
  inline SparseBasisStatusVector& operator=(SparseBasisStatusVector&& 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 SparseBasisStatusVector& default_instance() {
    return *reinterpret_cast<const SparseBasisStatusVector*>(
        &_SparseBasisStatusVector_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(SparseBasisStatusVector& a, SparseBasisStatusVector& b) { a.Swap(&b); }
  inline void Swap(SparseBasisStatusVector* 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(SparseBasisStatusVector* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SparseBasisStatusVector* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SparseBasisStatusVector>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SparseBasisStatusVector& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SparseBasisStatusVector& from) { SparseBasisStatusVector::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(SparseBasisStatusVector* 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.SparseBasisStatusVector"; }
 
  explicit SparseBasisStatusVector(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SparseBasisStatusVector(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SparseBasisStatusVector& from);
  SparseBasisStatusVector(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SparseBasisStatusVector&& from) noexcept
      : SparseBasisStatusVector(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 {
    kIdsFieldNumber = 1,
    kValuesFieldNumber = 2,
  };
  // repeated int64 ids = 1;
  int ids_size() const;
  private:
  int _internal_ids_size() const;
 
  public:
  void clear_ids() ;
  ::int64_t ids(int index) const;
  void set_ids(int index, ::int64_t value);
  void add_ids(::int64_t value);
  const ::google::protobuf::RepeatedField<::int64_t>& ids() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL mutable_ids();
 
  private:
  const ::google::protobuf::RepeatedField<::int64_t>& _internal_ids() const;
  ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL _internal_mutable_ids();
 
  public:
  // repeated .operations_research.math_opt.BasisStatusProto values = 2;
  int values_size() const;
  private:
  int _internal_values_size() const;
 
  public:
  void clear_values() ;
  public:
  ::operations_research::math_opt::BasisStatusProto values(int index) const;
  void set_values(int index, ::operations_research::math_opt::BasisStatusProto value);
  void add_values(::operations_research::math_opt::BasisStatusProto value);
  const ::google::protobuf::RepeatedField<int>& values() const;
  ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL mutable_values();
 
  private:
  const ::google::protobuf::RepeatedField<int>& _internal_values() const;
  ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL _internal_mutable_values();
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.SparseBasisStatusVector)
 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 SparseBasisStatusVector& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedField<::int64_t> ids_;
    ::google::protobuf::internal::CachedSize _ids_cached_byte_size_;
    ::google::protobuf::RepeatedField<int> values_;
    ::google::protobuf::internal::CachedSize _values_cached_byte_size_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fsolution_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SparseBasisStatusVector_class_data_;
// -------------------------------------------------------------------
 
class PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse final
    : public ::google::protobuf::internal::MapEntry<::int64_t, double,
                             ::google::protobuf::internal::WireFormatLite::TYPE_INT64,
                             ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE> {
 public:
  using SuperType =
      ::google::protobuf::internal::MapEntry<::int64_t, double,
                      ::google::protobuf::internal::WireFormatLite::TYPE_INT64,
                      ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>;
  PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse();
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse(::google::protobuf::internal::ConstantInitialized);
  explicit PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr const void* PROTOBUF_NONNULL internal_default_instance() {
    return &_PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse_default_instance_;
  }
 
 
  static constexpr auto InternalGenerateClassData_();
 
 private:
  friend class ::google::protobuf::MessageLite;
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fsolution_2eproto;
 
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<1, 2,
                                   0, 0,
                                   2>
      _table_;
 
  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_();
};
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL PrimalSolutionProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.PrimalSolutionProto) */ {
 public:
  inline PrimalSolutionProto() : PrimalSolutionProto(nullptr) {}
  ~PrimalSolutionProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(PrimalSolutionProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(PrimalSolutionProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR PrimalSolutionProto(::google::protobuf::internal::ConstantInitialized);
 
  inline PrimalSolutionProto(const PrimalSolutionProto& from) : PrimalSolutionProto(nullptr, from) {}
  inline PrimalSolutionProto(PrimalSolutionProto&& from) noexcept
      : PrimalSolutionProto(nullptr, ::std::move(from)) {}
  inline PrimalSolutionProto& operator=(const PrimalSolutionProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrimalSolutionProto& operator=(PrimalSolutionProto&& 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 PrimalSolutionProto& default_instance() {
    return *reinterpret_cast<const PrimalSolutionProto*>(
        &_PrimalSolutionProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(PrimalSolutionProto& a, PrimalSolutionProto& b) { a.Swap(&b); }
  inline void Swap(PrimalSolutionProto* 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(PrimalSolutionProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  PrimalSolutionProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<PrimalSolutionProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PrimalSolutionProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const PrimalSolutionProto& from) { PrimalSolutionProto::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(PrimalSolutionProto* 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.PrimalSolutionProto"; }
 
  explicit PrimalSolutionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  PrimalSolutionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PrimalSolutionProto& from);
  PrimalSolutionProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PrimalSolutionProto&& from) noexcept
      : PrimalSolutionProto(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 {
    kVariableValuesFieldNumber = 1,
    kObjectiveValueFieldNumber = 2,
    kFeasibilityStatusFieldNumber = 3,
    kAuxiliaryObjectiveValuesFieldNumber = 4,
  };
  // .operations_research.math_opt.SparseDoubleVectorProto variable_values = 1;
  bool has_variable_values() const;
  void clear_variable_values() ;
  const ::operations_research::math_opt::SparseDoubleVectorProto& variable_values() const;
  [[nodiscard]] ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE release_variable_values();
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL mutable_variable_values();
  void set_allocated_variable_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_variable_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE unsafe_arena_release_variable_values();
 
  private:
  const ::operations_research::math_opt::SparseDoubleVectorProto& _internal_variable_values() const;
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL _internal_mutable_variable_values();
 
  public:
  // double objective_value = 2;
  void clear_objective_value() ;
  double objective_value() const;
  void set_objective_value(double value);
 
  private:
  double _internal_objective_value() const;
  void _internal_set_objective_value(double value);
 
  public:
  // .operations_research.math_opt.SolutionStatusProto feasibility_status = 3;
  void clear_feasibility_status() ;
  ::operations_research::math_opt::SolutionStatusProto feasibility_status() const;
  void set_feasibility_status(::operations_research::math_opt::SolutionStatusProto value);
 
  private:
  ::operations_research::math_opt::SolutionStatusProto _internal_feasibility_status() const;
  void _internal_set_feasibility_status(::operations_research::math_opt::SolutionStatusProto value);
 
  public:
  // map<int64, double> auxiliary_objective_values = 4;
  int auxiliary_objective_values_size() const;
  private:
  int _internal_auxiliary_objective_values_size() const;
 
  public:
  void clear_auxiliary_objective_values() ;
  const ::google::protobuf::Map<::int64_t, double>& auxiliary_objective_values() const;
  ::google::protobuf::Map<::int64_t, double>* PROTOBUF_NONNULL mutable_auxiliary_objective_values();
 
  private:
  const ::google::protobuf::Map<::int64_t, double>& _internal_auxiliary_objective_values() const;
  ::google::protobuf::Map<::int64_t, double>* PROTOBUF_NONNULL _internal_mutable_auxiliary_objective_values();
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.PrimalSolutionProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 4,
                                   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 PrimalSolutionProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE variable_values_;
    double objective_value_;
    int feasibility_status_;
    ::google::protobuf::internal::MapField<PrimalSolutionProto_AuxiliaryObjectiveValuesEntry_DoNotUse, ::int64_t, double,
                      ::google::protobuf::internal::WireFormatLite::TYPE_INT64,
                      ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>
        auxiliary_objective_values_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fsolution_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull PrimalSolutionProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL PrimalRayProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.PrimalRayProto) */ {
 public:
  inline PrimalRayProto() : PrimalRayProto(nullptr) {}
  ~PrimalRayProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(PrimalRayProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(PrimalRayProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR PrimalRayProto(::google::protobuf::internal::ConstantInitialized);
 
  inline PrimalRayProto(const PrimalRayProto& from) : PrimalRayProto(nullptr, from) {}
  inline PrimalRayProto(PrimalRayProto&& from) noexcept
      : PrimalRayProto(nullptr, ::std::move(from)) {}
  inline PrimalRayProto& operator=(const PrimalRayProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline PrimalRayProto& operator=(PrimalRayProto&& 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 PrimalRayProto& default_instance() {
    return *reinterpret_cast<const PrimalRayProto*>(
        &_PrimalRayProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(PrimalRayProto& a, PrimalRayProto& b) { a.Swap(&b); }
  inline void Swap(PrimalRayProto* 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(PrimalRayProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  PrimalRayProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<PrimalRayProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const PrimalRayProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const PrimalRayProto& from) { PrimalRayProto::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(PrimalRayProto* 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.PrimalRayProto"; }
 
  explicit PrimalRayProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  PrimalRayProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PrimalRayProto& from);
  PrimalRayProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PrimalRayProto&& from) noexcept
      : PrimalRayProto(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 {
    kVariableValuesFieldNumber = 1,
  };
  // .operations_research.math_opt.SparseDoubleVectorProto variable_values = 1;
  bool has_variable_values() const;
  void clear_variable_values() ;
  const ::operations_research::math_opt::SparseDoubleVectorProto& variable_values() const;
  [[nodiscard]] ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE release_variable_values();
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL mutable_variable_values();
  void set_allocated_variable_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_variable_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE unsafe_arena_release_variable_values();
 
  private:
  const ::operations_research::math_opt::SparseDoubleVectorProto& _internal_variable_values() const;
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL _internal_mutable_variable_values();
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.PrimalRayProto)
 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 PrimalRayProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE variable_values_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fsolution_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull PrimalRayProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL DualSolutionProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.DualSolutionProto) */ {
 public:
  inline DualSolutionProto() : DualSolutionProto(nullptr) {}
  ~DualSolutionProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DualSolutionProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DualSolutionProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR DualSolutionProto(::google::protobuf::internal::ConstantInitialized);
 
  inline DualSolutionProto(const DualSolutionProto& from) : DualSolutionProto(nullptr, from) {}
  inline DualSolutionProto(DualSolutionProto&& from) noexcept
      : DualSolutionProto(nullptr, ::std::move(from)) {}
  inline DualSolutionProto& operator=(const DualSolutionProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DualSolutionProto& operator=(DualSolutionProto&& 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 DualSolutionProto& default_instance() {
    return *reinterpret_cast<const DualSolutionProto*>(
        &_DualSolutionProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(DualSolutionProto& a, DualSolutionProto& b) { a.Swap(&b); }
  inline void Swap(DualSolutionProto* 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(DualSolutionProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  DualSolutionProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<DualSolutionProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DualSolutionProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const DualSolutionProto& from) { DualSolutionProto::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(DualSolutionProto* 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.DualSolutionProto"; }
 
  explicit DualSolutionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DualSolutionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DualSolutionProto& from);
  DualSolutionProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DualSolutionProto&& from) noexcept
      : DualSolutionProto(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 {
    kDualValuesFieldNumber = 1,
    kReducedCostsFieldNumber = 2,
    kQuadraticDualValuesFieldNumber = 5,
    kObjectiveValueFieldNumber = 3,
    kFeasibilityStatusFieldNumber = 4,
  };
  // .operations_research.math_opt.SparseDoubleVectorProto dual_values = 1;
  bool has_dual_values() const;
  void clear_dual_values() ;
  const ::operations_research::math_opt::SparseDoubleVectorProto& dual_values() const;
  [[nodiscard]] ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE release_dual_values();
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL mutable_dual_values();
  void set_allocated_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE unsafe_arena_release_dual_values();
 
  private:
  const ::operations_research::math_opt::SparseDoubleVectorProto& _internal_dual_values() const;
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL _internal_mutable_dual_values();
 
  public:
  // .operations_research.math_opt.SparseDoubleVectorProto reduced_costs = 2;
  bool has_reduced_costs() const;
  void clear_reduced_costs() ;
  const ::operations_research::math_opt::SparseDoubleVectorProto& reduced_costs() const;
  [[nodiscard]] ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE release_reduced_costs();
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL mutable_reduced_costs();
  void set_allocated_reduced_costs(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_reduced_costs(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE unsafe_arena_release_reduced_costs();
 
  private:
  const ::operations_research::math_opt::SparseDoubleVectorProto& _internal_reduced_costs() const;
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL _internal_mutable_reduced_costs();
 
  public:
  // .operations_research.math_opt.SparseDoubleVectorProto quadratic_dual_values = 5;
  bool has_quadratic_dual_values() const;
  void clear_quadratic_dual_values() ;
  const ::operations_research::math_opt::SparseDoubleVectorProto& quadratic_dual_values() const;
  [[nodiscard]] ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE release_quadratic_dual_values();
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL mutable_quadratic_dual_values();
  void set_allocated_quadratic_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_quadratic_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE unsafe_arena_release_quadratic_dual_values();
 
  private:
  const ::operations_research::math_opt::SparseDoubleVectorProto& _internal_quadratic_dual_values() const;
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL _internal_mutable_quadratic_dual_values();
 
  public:
  // optional double objective_value = 3;
  bool has_objective_value() const;
  void clear_objective_value() ;
  double objective_value() const;
  void set_objective_value(double value);
 
  private:
  double _internal_objective_value() const;
  void _internal_set_objective_value(double value);
 
  public:
  // .operations_research.math_opt.SolutionStatusProto feasibility_status = 4;
  void clear_feasibility_status() ;
  ::operations_research::math_opt::SolutionStatusProto feasibility_status() const;
  void set_feasibility_status(::operations_research::math_opt::SolutionStatusProto value);
 
  private:
  ::operations_research::math_opt::SolutionStatusProto _internal_feasibility_status() const;
  void _internal_set_feasibility_status(::operations_research::math_opt::SolutionStatusProto value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.DualSolutionProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<3, 5,
                                   3, 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 DualSolutionProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE dual_values_;
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE reduced_costs_;
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE quadratic_dual_values_;
    double objective_value_;
    int feasibility_status_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fsolution_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull DualSolutionProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL DualRayProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.DualRayProto) */ {
 public:
  inline DualRayProto() : DualRayProto(nullptr) {}
  ~DualRayProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(DualRayProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(DualRayProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR DualRayProto(::google::protobuf::internal::ConstantInitialized);
 
  inline DualRayProto(const DualRayProto& from) : DualRayProto(nullptr, from) {}
  inline DualRayProto(DualRayProto&& from) noexcept
      : DualRayProto(nullptr, ::std::move(from)) {}
  inline DualRayProto& operator=(const DualRayProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline DualRayProto& operator=(DualRayProto&& 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 DualRayProto& default_instance() {
    return *reinterpret_cast<const DualRayProto*>(
        &_DualRayProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(DualRayProto& a, DualRayProto& b) { a.Swap(&b); }
  inline void Swap(DualRayProto* 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(DualRayProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  DualRayProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<DualRayProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const DualRayProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const DualRayProto& from) { DualRayProto::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(DualRayProto* 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.DualRayProto"; }
 
  explicit DualRayProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  DualRayProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const DualRayProto& from);
  DualRayProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, DualRayProto&& from) noexcept
      : DualRayProto(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 {
    kDualValuesFieldNumber = 1,
    kReducedCostsFieldNumber = 2,
  };
  // .operations_research.math_opt.SparseDoubleVectorProto dual_values = 1;
  bool has_dual_values() const;
  void clear_dual_values() ;
  const ::operations_research::math_opt::SparseDoubleVectorProto& dual_values() const;
  [[nodiscard]] ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE release_dual_values();
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL mutable_dual_values();
  void set_allocated_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE unsafe_arena_release_dual_values();
 
  private:
  const ::operations_research::math_opt::SparseDoubleVectorProto& _internal_dual_values() const;
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL _internal_mutable_dual_values();
 
  public:
  // .operations_research.math_opt.SparseDoubleVectorProto reduced_costs = 2;
  bool has_reduced_costs() const;
  void clear_reduced_costs() ;
  const ::operations_research::math_opt::SparseDoubleVectorProto& reduced_costs() const;
  [[nodiscard]] ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE release_reduced_costs();
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL mutable_reduced_costs();
  void set_allocated_reduced_costs(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_reduced_costs(::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE unsafe_arena_release_reduced_costs();
 
  private:
  const ::operations_research::math_opt::SparseDoubleVectorProto& _internal_reduced_costs() const;
  ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL _internal_mutable_reduced_costs();
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.DualRayProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<1, 2,
                                   2, 0,
                                   2>
      _table_;
 
  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const DualRayProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE dual_values_;
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE reduced_costs_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fsolution_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull DualRayProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL BasisProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.BasisProto) */ {
 public:
  inline BasisProto() : BasisProto(nullptr) {}
  ~BasisProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(BasisProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(BasisProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR BasisProto(::google::protobuf::internal::ConstantInitialized);
 
  inline BasisProto(const BasisProto& from) : BasisProto(nullptr, from) {}
  inline BasisProto(BasisProto&& from) noexcept
      : BasisProto(nullptr, ::std::move(from)) {}
  inline BasisProto& operator=(const BasisProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline BasisProto& operator=(BasisProto&& 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 BasisProto& default_instance() {
    return *reinterpret_cast<const BasisProto*>(
        &_BasisProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 6;
  friend void swap(BasisProto& a, BasisProto& b) { a.Swap(&b); }
  inline void Swap(BasisProto* 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(BasisProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  BasisProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<BasisProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const BasisProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const BasisProto& from) { BasisProto::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(BasisProto* 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.BasisProto"; }
 
  explicit BasisProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  BasisProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const BasisProto& from);
  BasisProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, BasisProto&& from) noexcept
      : BasisProto(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 {
    kConstraintStatusFieldNumber = 1,
    kVariableStatusFieldNumber = 2,
    kBasicDualFeasibilityFieldNumber = 3,
  };
  // .operations_research.math_opt.SparseBasisStatusVector constraint_status = 1;
  bool has_constraint_status() const;
  void clear_constraint_status() ;
  const ::operations_research::math_opt::SparseBasisStatusVector& constraint_status() const;
  [[nodiscard]] ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE release_constraint_status();
  ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NONNULL mutable_constraint_status();
  void set_allocated_constraint_status(::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_constraint_status(::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE unsafe_arena_release_constraint_status();
 
  private:
  const ::operations_research::math_opt::SparseBasisStatusVector& _internal_constraint_status() const;
  ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NONNULL _internal_mutable_constraint_status();
 
  public:
  // .operations_research.math_opt.SparseBasisStatusVector variable_status = 2;
  bool has_variable_status() const;
  void clear_variable_status() ;
  const ::operations_research::math_opt::SparseBasisStatusVector& variable_status() const;
  [[nodiscard]] ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE release_variable_status();
  ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NONNULL mutable_variable_status();
  void set_allocated_variable_status(::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_variable_status(::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE unsafe_arena_release_variable_status();
 
  private:
  const ::operations_research::math_opt::SparseBasisStatusVector& _internal_variable_status() const;
  ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NONNULL _internal_mutable_variable_status();
 
  public:
  // .operations_research.math_opt.SolutionStatusProto basic_dual_feasibility = 3;
  void clear_basic_dual_feasibility() ;
  ::operations_research::math_opt::SolutionStatusProto basic_dual_feasibility() const;
  void set_basic_dual_feasibility(::operations_research::math_opt::SolutionStatusProto value);
 
  private:
  ::operations_research::math_opt::SolutionStatusProto _internal_basic_dual_feasibility() const;
  void _internal_set_basic_dual_feasibility(::operations_research::math_opt::SolutionStatusProto value);
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.BasisProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 3,
                                   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 BasisProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE constraint_status_;
    ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE variable_status_;
    int basic_dual_feasibility_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fsolution_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull BasisProto_class_data_;
// -------------------------------------------------------------------
 
class OR_PROTO_DLL SolutionProto final : public ::google::protobuf::Message
/* @@protoc_insertion_point(class_definition:operations_research.math_opt.SolutionProto) */ {
 public:
  inline SolutionProto() : SolutionProto(nullptr) {}
  ~SolutionProto() PROTOBUF_FINAL;
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SolutionProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SolutionProto));
  }
#endif
 
  template <typename = void>
  explicit PROTOBUF_CONSTEXPR SolutionProto(::google::protobuf::internal::ConstantInitialized);
 
  inline SolutionProto(const SolutionProto& from) : SolutionProto(nullptr, from) {}
  inline SolutionProto(SolutionProto&& from) noexcept
      : SolutionProto(nullptr, ::std::move(from)) {}
  inline SolutionProto& operator=(const SolutionProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline SolutionProto& operator=(SolutionProto&& 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 SolutionProto& default_instance() {
    return *reinterpret_cast<const SolutionProto*>(
        &_SolutionProto_default_instance_);
  }
  static constexpr int kIndexInFileMessages = 7;
  friend void swap(SolutionProto& a, SolutionProto& b) { a.Swap(&b); }
  inline void Swap(SolutionProto* 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(SolutionProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }
 
  // implements Message ----------------------------------------------
 
  SolutionProto* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::Message::DefaultConstruct<SolutionProto>(arena);
  }
  using ::google::protobuf::Message::CopyFrom;
  void CopyFrom(const SolutionProto& from);
  using ::google::protobuf::Message::MergeFrom;
  void MergeFrom(const SolutionProto& from) { SolutionProto::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(SolutionProto* 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.SolutionProto"; }
 
  explicit SolutionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SolutionProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SolutionProto& from);
  SolutionProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SolutionProto&& from) noexcept
      : SolutionProto(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 {
    kPrimalSolutionFieldNumber = 1,
    kDualSolutionFieldNumber = 2,
    kBasisFieldNumber = 3,
  };
  // optional .operations_research.math_opt.PrimalSolutionProto primal_solution = 1;
  bool has_primal_solution() const;
  void clear_primal_solution() ;
  const ::operations_research::math_opt::PrimalSolutionProto& primal_solution() const;
  [[nodiscard]] ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NULLABLE release_primal_solution();
  ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NONNULL mutable_primal_solution();
  void set_allocated_primal_solution(::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_primal_solution(::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NULLABLE unsafe_arena_release_primal_solution();
 
  private:
  const ::operations_research::math_opt::PrimalSolutionProto& _internal_primal_solution() const;
  ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NONNULL _internal_mutable_primal_solution();
 
  public:
  // optional .operations_research.math_opt.DualSolutionProto dual_solution = 2;
  bool has_dual_solution() const;
  void clear_dual_solution() ;
  const ::operations_research::math_opt::DualSolutionProto& dual_solution() const;
  [[nodiscard]] ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NULLABLE release_dual_solution();
  ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NONNULL mutable_dual_solution();
  void set_allocated_dual_solution(::operations_research::math_opt::DualSolutionProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_dual_solution(::operations_research::math_opt::DualSolutionProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NULLABLE unsafe_arena_release_dual_solution();
 
  private:
  const ::operations_research::math_opt::DualSolutionProto& _internal_dual_solution() const;
  ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NONNULL _internal_mutable_dual_solution();
 
  public:
  // optional .operations_research.math_opt.BasisProto basis = 3;
  bool has_basis() const;
  void clear_basis() ;
  const ::operations_research::math_opt::BasisProto& basis() const;
  [[nodiscard]] ::operations_research::math_opt::BasisProto* PROTOBUF_NULLABLE release_basis();
  ::operations_research::math_opt::BasisProto* PROTOBUF_NONNULL mutable_basis();
  void set_allocated_basis(::operations_research::math_opt::BasisProto* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_basis(::operations_research::math_opt::BasisProto* PROTOBUF_NULLABLE value);
  ::operations_research::math_opt::BasisProto* PROTOBUF_NULLABLE unsafe_arena_release_basis();
 
  private:
  const ::operations_research::math_opt::BasisProto& _internal_basis() const;
  ::operations_research::math_opt::BasisProto* PROTOBUF_NONNULL _internal_mutable_basis();
 
  public:
  // @@protoc_insertion_point(class_scope:operations_research.math_opt.SolutionProto)
 private:
  class _Internal;
  friend class ::google::protobuf::internal::TcParser;
  static const ::google::protobuf::internal::TcParseTable<2, 3,
                                   3, 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 SolutionProto& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NULLABLE primal_solution_;
    ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NULLABLE dual_solution_;
    ::operations_research::math_opt::BasisProto* PROTOBUF_NULLABLE basis_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_ortools_2fmath_5fopt_2fsolution_2eproto;
};
 
OR_PROTO_DLL extern const ::google::protobuf::internal::ClassDataFull SolutionProto_class_data_;
 
// ===================================================================
 
 
 
 
// ===================================================================
 
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------
 
// -------------------------------------------------------------------
 
// PrimalSolutionProto
 
// .operations_research.math_opt.SparseDoubleVectorProto variable_values = 1;
inline bool PrimalSolutionProto::has_variable_values() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.variable_values_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& PrimalSolutionProto::_internal_variable_values() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseDoubleVectorProto* p = _impl_.variable_values_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseDoubleVectorProto&>(::operations_research::math_opt::_SparseDoubleVectorProto_default_instance_);
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& PrimalSolutionProto::variable_values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.PrimalSolutionProto.variable_values)
  return _internal_variable_values();
}
inline void PrimalSolutionProto::unsafe_arena_set_allocated_variable_values(
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.variable_values_);
  }
  _impl_.variable_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(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.PrimalSolutionProto.variable_values)
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE PrimalSolutionProto::release_variable_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* released = _impl_.variable_values_;
  _impl_.variable_values_ = 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::SparseDoubleVectorProto* PROTOBUF_NULLABLE PrimalSolutionProto::unsafe_arena_release_variable_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.PrimalSolutionProto.variable_values)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* temp = _impl_.variable_values_;
  _impl_.variable_values_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL PrimalSolutionProto::_internal_mutable_variable_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.variable_values_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseDoubleVectorProto>(GetArena());
    _impl_.variable_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(p);
  }
  return _impl_.variable_values_;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL PrimalSolutionProto::mutable_variable_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* _msg = _internal_mutable_variable_values();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.PrimalSolutionProto.variable_values)
  return _msg;
}
inline void PrimalSolutionProto::set_allocated_variable_values(::operations_research::math_opt::SparseDoubleVectorProto* 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_.variable_values_);
  }
 
  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_.variable_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.PrimalSolutionProto.variable_values)
}
 
// double objective_value = 2;
inline void PrimalSolutionProto::clear_objective_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_value_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline double PrimalSolutionProto::objective_value() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.PrimalSolutionProto.objective_value)
  return _internal_objective_value();
}
inline void PrimalSolutionProto::set_objective_value(double value) {
  _internal_set_objective_value(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.PrimalSolutionProto.objective_value)
}
inline double PrimalSolutionProto::_internal_objective_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.objective_value_;
}
inline void PrimalSolutionProto::_internal_set_objective_value(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_value_ = value;
}
 
// map<int64, double> auxiliary_objective_values = 4;
inline int PrimalSolutionProto::_internal_auxiliary_objective_values_size() const {
  return _internal_auxiliary_objective_values().size();
}
inline int PrimalSolutionProto::auxiliary_objective_values_size() const {
  return _internal_auxiliary_objective_values_size();
}
inline void PrimalSolutionProto::clear_auxiliary_objective_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.auxiliary_objective_values_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000008U);
}
inline const ::google::protobuf::Map<::int64_t, double>& PrimalSolutionProto::_internal_auxiliary_objective_values() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.auxiliary_objective_values_.GetMap();
}
inline const ::google::protobuf::Map<::int64_t, double>& PrimalSolutionProto::auxiliary_objective_values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_map:operations_research.math_opt.PrimalSolutionProto.auxiliary_objective_values)
  return _internal_auxiliary_objective_values();
}
inline ::google::protobuf::Map<::int64_t, double>* PROTOBUF_NONNULL PrimalSolutionProto::_internal_mutable_auxiliary_objective_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.auxiliary_objective_values_.MutableMap();
}
inline ::google::protobuf::Map<::int64_t, double>* PROTOBUF_NONNULL PrimalSolutionProto::mutable_auxiliary_objective_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_map:operations_research.math_opt.PrimalSolutionProto.auxiliary_objective_values)
  return _internal_mutable_auxiliary_objective_values();
}
 
// .operations_research.math_opt.SolutionStatusProto feasibility_status = 3;
inline void PrimalSolutionProto::clear_feasibility_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_status_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::operations_research::math_opt::SolutionStatusProto PrimalSolutionProto::feasibility_status() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.PrimalSolutionProto.feasibility_status)
  return _internal_feasibility_status();
}
inline void PrimalSolutionProto::set_feasibility_status(::operations_research::math_opt::SolutionStatusProto value) {
  _internal_set_feasibility_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.PrimalSolutionProto.feasibility_status)
}
inline ::operations_research::math_opt::SolutionStatusProto PrimalSolutionProto::_internal_feasibility_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::SolutionStatusProto>(_impl_.feasibility_status_);
}
inline void PrimalSolutionProto::_internal_set_feasibility_status(::operations_research::math_opt::SolutionStatusProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_status_ = value;
}
 
// -------------------------------------------------------------------
 
// PrimalRayProto
 
// .operations_research.math_opt.SparseDoubleVectorProto variable_values = 1;
inline bool PrimalRayProto::has_variable_values() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.variable_values_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& PrimalRayProto::_internal_variable_values() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseDoubleVectorProto* p = _impl_.variable_values_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseDoubleVectorProto&>(::operations_research::math_opt::_SparseDoubleVectorProto_default_instance_);
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& PrimalRayProto::variable_values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.PrimalRayProto.variable_values)
  return _internal_variable_values();
}
inline void PrimalRayProto::unsafe_arena_set_allocated_variable_values(
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.variable_values_);
  }
  _impl_.variable_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(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.PrimalRayProto.variable_values)
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE PrimalRayProto::release_variable_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* released = _impl_.variable_values_;
  _impl_.variable_values_ = 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::SparseDoubleVectorProto* PROTOBUF_NULLABLE PrimalRayProto::unsafe_arena_release_variable_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.PrimalRayProto.variable_values)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* temp = _impl_.variable_values_;
  _impl_.variable_values_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL PrimalRayProto::_internal_mutable_variable_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.variable_values_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseDoubleVectorProto>(GetArena());
    _impl_.variable_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(p);
  }
  return _impl_.variable_values_;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL PrimalRayProto::mutable_variable_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* _msg = _internal_mutable_variable_values();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.PrimalRayProto.variable_values)
  return _msg;
}
inline void PrimalRayProto::set_allocated_variable_values(::operations_research::math_opt::SparseDoubleVectorProto* 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_.variable_values_);
  }
 
  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_.variable_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.PrimalRayProto.variable_values)
}
 
// -------------------------------------------------------------------
 
// DualSolutionProto
 
// .operations_research.math_opt.SparseDoubleVectorProto dual_values = 1;
inline bool DualSolutionProto::has_dual_values() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.dual_values_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualSolutionProto::_internal_dual_values() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseDoubleVectorProto* p = _impl_.dual_values_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseDoubleVectorProto&>(::operations_research::math_opt::_SparseDoubleVectorProto_default_instance_);
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualSolutionProto::dual_values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.DualSolutionProto.dual_values)
  return _internal_dual_values();
}
inline void DualSolutionProto::unsafe_arena_set_allocated_dual_values(
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dual_values_);
  }
  _impl_.dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(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.DualSolutionProto.dual_values)
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualSolutionProto::release_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* released = _impl_.dual_values_;
  _impl_.dual_values_ = 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::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualSolutionProto::unsafe_arena_release_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.DualSolutionProto.dual_values)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* temp = _impl_.dual_values_;
  _impl_.dual_values_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualSolutionProto::_internal_mutable_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dual_values_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseDoubleVectorProto>(GetArena());
    _impl_.dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(p);
  }
  return _impl_.dual_values_;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualSolutionProto::mutable_dual_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* _msg = _internal_mutable_dual_values();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.DualSolutionProto.dual_values)
  return _msg;
}
inline void DualSolutionProto::set_allocated_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* 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_.dual_values_);
  }
 
  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_.dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.DualSolutionProto.dual_values)
}
 
// .operations_research.math_opt.SparseDoubleVectorProto quadratic_dual_values = 5;
inline bool DualSolutionProto::has_quadratic_dual_values() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.quadratic_dual_values_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualSolutionProto::_internal_quadratic_dual_values() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseDoubleVectorProto* p = _impl_.quadratic_dual_values_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseDoubleVectorProto&>(::operations_research::math_opt::_SparseDoubleVectorProto_default_instance_);
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualSolutionProto::quadratic_dual_values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.DualSolutionProto.quadratic_dual_values)
  return _internal_quadratic_dual_values();
}
inline void DualSolutionProto::unsafe_arena_set_allocated_quadratic_dual_values(
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.quadratic_dual_values_);
  }
  _impl_.quadratic_dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(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.DualSolutionProto.quadratic_dual_values)
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualSolutionProto::release_quadratic_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::SparseDoubleVectorProto* released = _impl_.quadratic_dual_values_;
  _impl_.quadratic_dual_values_ = 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::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualSolutionProto::unsafe_arena_release_quadratic_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.DualSolutionProto.quadratic_dual_values)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::SparseDoubleVectorProto* temp = _impl_.quadratic_dual_values_;
  _impl_.quadratic_dual_values_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualSolutionProto::_internal_mutable_quadratic_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.quadratic_dual_values_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseDoubleVectorProto>(GetArena());
    _impl_.quadratic_dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(p);
  }
  return _impl_.quadratic_dual_values_;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualSolutionProto::mutable_quadratic_dual_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::SparseDoubleVectorProto* _msg = _internal_mutable_quadratic_dual_values();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.DualSolutionProto.quadratic_dual_values)
  return _msg;
}
inline void DualSolutionProto::set_allocated_quadratic_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* 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_.quadratic_dual_values_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
 
  _impl_.quadratic_dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.DualSolutionProto.quadratic_dual_values)
}
 
// .operations_research.math_opt.SparseDoubleVectorProto reduced_costs = 2;
inline bool DualSolutionProto::has_reduced_costs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.reduced_costs_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualSolutionProto::_internal_reduced_costs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseDoubleVectorProto* p = _impl_.reduced_costs_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseDoubleVectorProto&>(::operations_research::math_opt::_SparseDoubleVectorProto_default_instance_);
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualSolutionProto::reduced_costs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.DualSolutionProto.reduced_costs)
  return _internal_reduced_costs();
}
inline void DualSolutionProto::unsafe_arena_set_allocated_reduced_costs(
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.reduced_costs_);
  }
  _impl_.reduced_costs_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(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.DualSolutionProto.reduced_costs)
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualSolutionProto::release_reduced_costs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseDoubleVectorProto* released = _impl_.reduced_costs_;
  _impl_.reduced_costs_ = 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::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualSolutionProto::unsafe_arena_release_reduced_costs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.DualSolutionProto.reduced_costs)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseDoubleVectorProto* temp = _impl_.reduced_costs_;
  _impl_.reduced_costs_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualSolutionProto::_internal_mutable_reduced_costs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.reduced_costs_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseDoubleVectorProto>(GetArena());
    _impl_.reduced_costs_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(p);
  }
  return _impl_.reduced_costs_;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualSolutionProto::mutable_reduced_costs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseDoubleVectorProto* _msg = _internal_mutable_reduced_costs();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.DualSolutionProto.reduced_costs)
  return _msg;
}
inline void DualSolutionProto::set_allocated_reduced_costs(::operations_research::math_opt::SparseDoubleVectorProto* 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_.reduced_costs_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
 
  _impl_.reduced_costs_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.DualSolutionProto.reduced_costs)
}
 
// optional double objective_value = 3;
inline bool DualSolutionProto::has_objective_value() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void DualSolutionProto::clear_objective_value() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_value_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000008U);
}
inline double DualSolutionProto::objective_value() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.DualSolutionProto.objective_value)
  return _internal_objective_value();
}
inline void DualSolutionProto::set_objective_value(double value) {
  _internal_set_objective_value(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.DualSolutionProto.objective_value)
}
inline double DualSolutionProto::_internal_objective_value() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.objective_value_;
}
inline void DualSolutionProto::_internal_set_objective_value(double value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.objective_value_ = value;
}
 
// .operations_research.math_opt.SolutionStatusProto feasibility_status = 4;
inline void DualSolutionProto::clear_feasibility_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_status_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000010U);
}
inline ::operations_research::math_opt::SolutionStatusProto DualSolutionProto::feasibility_status() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.DualSolutionProto.feasibility_status)
  return _internal_feasibility_status();
}
inline void DualSolutionProto::set_feasibility_status(::operations_research::math_opt::SolutionStatusProto value) {
  _internal_set_feasibility_status(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.DualSolutionProto.feasibility_status)
}
inline ::operations_research::math_opt::SolutionStatusProto DualSolutionProto::_internal_feasibility_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::SolutionStatusProto>(_impl_.feasibility_status_);
}
inline void DualSolutionProto::_internal_set_feasibility_status(::operations_research::math_opt::SolutionStatusProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.feasibility_status_ = value;
}
 
// -------------------------------------------------------------------
 
// DualRayProto
 
// .operations_research.math_opt.SparseDoubleVectorProto dual_values = 1;
inline bool DualRayProto::has_dual_values() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.dual_values_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualRayProto::_internal_dual_values() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseDoubleVectorProto* p = _impl_.dual_values_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseDoubleVectorProto&>(::operations_research::math_opt::_SparseDoubleVectorProto_default_instance_);
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualRayProto::dual_values() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.DualRayProto.dual_values)
  return _internal_dual_values();
}
inline void DualRayProto::unsafe_arena_set_allocated_dual_values(
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dual_values_);
  }
  _impl_.dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(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.DualRayProto.dual_values)
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualRayProto::release_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* released = _impl_.dual_values_;
  _impl_.dual_values_ = 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::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualRayProto::unsafe_arena_release_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.DualRayProto.dual_values)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* temp = _impl_.dual_values_;
  _impl_.dual_values_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualRayProto::_internal_mutable_dual_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dual_values_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseDoubleVectorProto>(GetArena());
    _impl_.dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(p);
  }
  return _impl_.dual_values_;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualRayProto::mutable_dual_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseDoubleVectorProto* _msg = _internal_mutable_dual_values();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.DualRayProto.dual_values)
  return _msg;
}
inline void DualRayProto::set_allocated_dual_values(::operations_research::math_opt::SparseDoubleVectorProto* 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_.dual_values_);
  }
 
  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_.dual_values_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.DualRayProto.dual_values)
}
 
// .operations_research.math_opt.SparseDoubleVectorProto reduced_costs = 2;
inline bool DualRayProto::has_reduced_costs() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.reduced_costs_ != nullptr);
  return value;
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualRayProto::_internal_reduced_costs() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseDoubleVectorProto* p = _impl_.reduced_costs_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseDoubleVectorProto&>(::operations_research::math_opt::_SparseDoubleVectorProto_default_instance_);
}
inline const ::operations_research::math_opt::SparseDoubleVectorProto& DualRayProto::reduced_costs() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.DualRayProto.reduced_costs)
  return _internal_reduced_costs();
}
inline void DualRayProto::unsafe_arena_set_allocated_reduced_costs(
    ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.reduced_costs_);
  }
  _impl_.reduced_costs_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(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.DualRayProto.reduced_costs)
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualRayProto::release_reduced_costs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseDoubleVectorProto* released = _impl_.reduced_costs_;
  _impl_.reduced_costs_ = 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::SparseDoubleVectorProto* PROTOBUF_NULLABLE DualRayProto::unsafe_arena_release_reduced_costs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.DualRayProto.reduced_costs)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseDoubleVectorProto* temp = _impl_.reduced_costs_;
  _impl_.reduced_costs_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualRayProto::_internal_mutable_reduced_costs() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.reduced_costs_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseDoubleVectorProto>(GetArena());
    _impl_.reduced_costs_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(p);
  }
  return _impl_.reduced_costs_;
}
inline ::operations_research::math_opt::SparseDoubleVectorProto* PROTOBUF_NONNULL DualRayProto::mutable_reduced_costs()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseDoubleVectorProto* _msg = _internal_mutable_reduced_costs();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.DualRayProto.reduced_costs)
  return _msg;
}
inline void DualRayProto::set_allocated_reduced_costs(::operations_research::math_opt::SparseDoubleVectorProto* 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_.reduced_costs_);
  }
 
  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
 
  _impl_.reduced_costs_ = reinterpret_cast<::operations_research::math_opt::SparseDoubleVectorProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.DualRayProto.reduced_costs)
}
 
// -------------------------------------------------------------------
 
// SparseBasisStatusVector
 
// repeated int64 ids = 1;
inline int SparseBasisStatusVector::_internal_ids_size() const {
  return _internal_ids().size();
}
inline int SparseBasisStatusVector::ids_size() const {
  return _internal_ids_size();
}
inline void SparseBasisStatusVector::clear_ids() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.ids_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000001U);
}
inline ::int64_t SparseBasisStatusVector::ids(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SparseBasisStatusVector.ids)
  return _internal_ids().Get(index);
}
inline void SparseBasisStatusVector::set_ids(int index, ::int64_t value) {
  _internal_mutable_ids()->Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SparseBasisStatusVector.ids)
}
inline void SparseBasisStatusVector::add_ids(::int64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_ids()->Add(value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:operations_research.math_opt.SparseBasisStatusVector.ids)
}
inline const ::google::protobuf::RepeatedField<::int64_t>& SparseBasisStatusVector::ids() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.math_opt.SparseBasisStatusVector.ids)
  return _internal_ids();
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL SparseBasisStatusVector::mutable_ids()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.math_opt.SparseBasisStatusVector.ids)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_ids();
}
inline const ::google::protobuf::RepeatedField<::int64_t>&
SparseBasisStatusVector::_internal_ids() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.ids_;
}
inline ::google::protobuf::RepeatedField<::int64_t>* PROTOBUF_NONNULL
SparseBasisStatusVector::_internal_mutable_ids() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.ids_;
}
 
// repeated .operations_research.math_opt.BasisStatusProto values = 2;
inline int SparseBasisStatusVector::_internal_values_size() const {
  return _internal_values().size();
}
inline int SparseBasisStatusVector::values_size() const {
  return _internal_values_size();
}
inline void SparseBasisStatusVector::clear_values() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.values_.Clear();
  ClearHasBitForRepeated(_impl_._has_bits_[0],
                  0x00000002U);
}
inline ::operations_research::math_opt::BasisStatusProto SparseBasisStatusVector::values(int index) const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SparseBasisStatusVector.values)
  return static_cast<::operations_research::math_opt::BasisStatusProto>(_internal_values().Get(index));
}
inline void SparseBasisStatusVector::set_values(int index, ::operations_research::math_opt::BasisStatusProto value) {
  _internal_mutable_values()->Set(index, value);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.SparseBasisStatusVector.values)
}
inline void SparseBasisStatusVector::add_values(::operations_research::math_opt::BasisStatusProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _internal_mutable_values()->Add(value);
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:operations_research.math_opt.SparseBasisStatusVector.values)
}
inline const ::google::protobuf::RepeatedField<int>& SparseBasisStatusVector::values() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:operations_research.math_opt.SparseBasisStatusVector.values)
  return _internal_values();
}
inline ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL SparseBasisStatusVector::mutable_values()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:operations_research.math_opt.SparseBasisStatusVector.values)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_values();
}
inline const ::google::protobuf::RepeatedField<int>& SparseBasisStatusVector::_internal_values()
    const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.values_;
}
inline ::google::protobuf::RepeatedField<int>* PROTOBUF_NONNULL
SparseBasisStatusVector::_internal_mutable_values() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.values_;
}
 
// -------------------------------------------------------------------
 
// BasisProto
 
// .operations_research.math_opt.SparseBasisStatusVector constraint_status = 1;
inline bool BasisProto::has_constraint_status() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.constraint_status_ != nullptr);
  return value;
}
inline void BasisProto::clear_constraint_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.constraint_status_ != nullptr) _impl_.constraint_status_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::operations_research::math_opt::SparseBasisStatusVector& BasisProto::_internal_constraint_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseBasisStatusVector* p = _impl_.constraint_status_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseBasisStatusVector&>(::operations_research::math_opt::_SparseBasisStatusVector_default_instance_);
}
inline const ::operations_research::math_opt::SparseBasisStatusVector& BasisProto::constraint_status() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.BasisProto.constraint_status)
  return _internal_constraint_status();
}
inline void BasisProto::unsafe_arena_set_allocated_constraint_status(
    ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.constraint_status_);
  }
  _impl_.constraint_status_ = reinterpret_cast<::operations_research::math_opt::SparseBasisStatusVector*>(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.BasisProto.constraint_status)
}
inline ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE BasisProto::release_constraint_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseBasisStatusVector* released = _impl_.constraint_status_;
  _impl_.constraint_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::SparseBasisStatusVector* PROTOBUF_NULLABLE BasisProto::unsafe_arena_release_constraint_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.BasisProto.constraint_status)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseBasisStatusVector* temp = _impl_.constraint_status_;
  _impl_.constraint_status_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NONNULL BasisProto::_internal_mutable_constraint_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.constraint_status_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseBasisStatusVector>(GetArena());
    _impl_.constraint_status_ = reinterpret_cast<::operations_research::math_opt::SparseBasisStatusVector*>(p);
  }
  return _impl_.constraint_status_;
}
inline ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NONNULL BasisProto::mutable_constraint_status()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::SparseBasisStatusVector* _msg = _internal_mutable_constraint_status();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.BasisProto.constraint_status)
  return _msg;
}
inline void BasisProto::set_allocated_constraint_status(::operations_research::math_opt::SparseBasisStatusVector* 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_.constraint_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], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
 
  _impl_.constraint_status_ = reinterpret_cast<::operations_research::math_opt::SparseBasisStatusVector*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.BasisProto.constraint_status)
}
 
// .operations_research.math_opt.SparseBasisStatusVector variable_status = 2;
inline bool BasisProto::has_variable_status() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.variable_status_ != nullptr);
  return value;
}
inline void BasisProto::clear_variable_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.variable_status_ != nullptr) _impl_.variable_status_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::operations_research::math_opt::SparseBasisStatusVector& BasisProto::_internal_variable_status() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::SparseBasisStatusVector* p = _impl_.variable_status_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::SparseBasisStatusVector&>(::operations_research::math_opt::_SparseBasisStatusVector_default_instance_);
}
inline const ::operations_research::math_opt::SparseBasisStatusVector& BasisProto::variable_status() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.BasisProto.variable_status)
  return _internal_variable_status();
}
inline void BasisProto::unsafe_arena_set_allocated_variable_status(
    ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.variable_status_);
  }
  _impl_.variable_status_ = reinterpret_cast<::operations_research::math_opt::SparseBasisStatusVector*>(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.BasisProto.variable_status)
}
inline ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NULLABLE BasisProto::release_variable_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseBasisStatusVector* released = _impl_.variable_status_;
  _impl_.variable_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::SparseBasisStatusVector* PROTOBUF_NULLABLE BasisProto::unsafe_arena_release_variable_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.BasisProto.variable_status)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseBasisStatusVector* temp = _impl_.variable_status_;
  _impl_.variable_status_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NONNULL BasisProto::_internal_mutable_variable_status() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.variable_status_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::SparseBasisStatusVector>(GetArena());
    _impl_.variable_status_ = reinterpret_cast<::operations_research::math_opt::SparseBasisStatusVector*>(p);
  }
  return _impl_.variable_status_;
}
inline ::operations_research::math_opt::SparseBasisStatusVector* PROTOBUF_NONNULL BasisProto::mutable_variable_status()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::SparseBasisStatusVector* _msg = _internal_mutable_variable_status();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.BasisProto.variable_status)
  return _msg;
}
inline void BasisProto::set_allocated_variable_status(::operations_research::math_opt::SparseBasisStatusVector* 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_.variable_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_.variable_status_ = reinterpret_cast<::operations_research::math_opt::SparseBasisStatusVector*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.BasisProto.variable_status)
}
 
// .operations_research.math_opt.SolutionStatusProto basic_dual_feasibility = 3;
inline void BasisProto::clear_basic_dual_feasibility() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.basic_dual_feasibility_ = 0;
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline ::operations_research::math_opt::SolutionStatusProto BasisProto::basic_dual_feasibility() const {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.BasisProto.basic_dual_feasibility)
  return _internal_basic_dual_feasibility();
}
inline void BasisProto::set_basic_dual_feasibility(::operations_research::math_opt::SolutionStatusProto value) {
  _internal_set_basic_dual_feasibility(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:operations_research.math_opt.BasisProto.basic_dual_feasibility)
}
inline ::operations_research::math_opt::SolutionStatusProto BasisProto::_internal_basic_dual_feasibility() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::operations_research::math_opt::SolutionStatusProto>(_impl_.basic_dual_feasibility_);
}
inline void BasisProto::_internal_set_basic_dual_feasibility(::operations_research::math_opt::SolutionStatusProto value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.basic_dual_feasibility_ = value;
}
 
// -------------------------------------------------------------------
 
// SolutionProto
 
// optional .operations_research.math_opt.PrimalSolutionProto primal_solution = 1;
inline bool SolutionProto::has_primal_solution() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  PROTOBUF_ASSUME(!value || _impl_.primal_solution_ != nullptr);
  return value;
}
inline void SolutionProto::clear_primal_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.primal_solution_ != nullptr) _impl_.primal_solution_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000001U);
}
inline const ::operations_research::math_opt::PrimalSolutionProto& SolutionProto::_internal_primal_solution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::PrimalSolutionProto* p = _impl_.primal_solution_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::PrimalSolutionProto&>(::operations_research::math_opt::_PrimalSolutionProto_default_instance_);
}
inline const ::operations_research::math_opt::PrimalSolutionProto& SolutionProto::primal_solution() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolutionProto.primal_solution)
  return _internal_primal_solution();
}
inline void SolutionProto::unsafe_arena_set_allocated_primal_solution(
    ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.primal_solution_);
  }
  _impl_.primal_solution_ = reinterpret_cast<::operations_research::math_opt::PrimalSolutionProto*>(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.SolutionProto.primal_solution)
}
inline ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NULLABLE SolutionProto::release_primal_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::PrimalSolutionProto* released = _impl_.primal_solution_;
  _impl_.primal_solution_ = 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::PrimalSolutionProto* PROTOBUF_NULLABLE SolutionProto::unsafe_arena_release_primal_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolutionProto.primal_solution)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::PrimalSolutionProto* temp = _impl_.primal_solution_;
  _impl_.primal_solution_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NONNULL SolutionProto::_internal_mutable_primal_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.primal_solution_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::PrimalSolutionProto>(GetArena());
    _impl_.primal_solution_ = reinterpret_cast<::operations_research::math_opt::PrimalSolutionProto*>(p);
  }
  return _impl_.primal_solution_;
}
inline ::operations_research::math_opt::PrimalSolutionProto* PROTOBUF_NONNULL SolutionProto::mutable_primal_solution()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::operations_research::math_opt::PrimalSolutionProto* _msg = _internal_mutable_primal_solution();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolutionProto.primal_solution)
  return _msg;
}
inline void SolutionProto::set_allocated_primal_solution(::operations_research::math_opt::PrimalSolutionProto* 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_.primal_solution_);
  }
 
  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], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
 
  _impl_.primal_solution_ = reinterpret_cast<::operations_research::math_opt::PrimalSolutionProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolutionProto.primal_solution)
}
 
// optional .operations_research.math_opt.DualSolutionProto dual_solution = 2;
inline bool SolutionProto::has_dual_solution() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.dual_solution_ != nullptr);
  return value;
}
inline void SolutionProto::clear_dual_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dual_solution_ != nullptr) _impl_.dual_solution_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
inline const ::operations_research::math_opt::DualSolutionProto& SolutionProto::_internal_dual_solution() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::DualSolutionProto* p = _impl_.dual_solution_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::DualSolutionProto&>(::operations_research::math_opt::_DualSolutionProto_default_instance_);
}
inline const ::operations_research::math_opt::DualSolutionProto& SolutionProto::dual_solution() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolutionProto.dual_solution)
  return _internal_dual_solution();
}
inline void SolutionProto::unsafe_arena_set_allocated_dual_solution(
    ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.dual_solution_);
  }
  _impl_.dual_solution_ = reinterpret_cast<::operations_research::math_opt::DualSolutionProto*>(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.SolutionProto.dual_solution)
}
inline ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NULLABLE SolutionProto::release_dual_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::DualSolutionProto* released = _impl_.dual_solution_;
  _impl_.dual_solution_ = 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::DualSolutionProto* PROTOBUF_NULLABLE SolutionProto::unsafe_arena_release_dual_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolutionProto.dual_solution)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::DualSolutionProto* temp = _impl_.dual_solution_;
  _impl_.dual_solution_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NONNULL SolutionProto::_internal_mutable_dual_solution() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.dual_solution_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::DualSolutionProto>(GetArena());
    _impl_.dual_solution_ = reinterpret_cast<::operations_research::math_opt::DualSolutionProto*>(p);
  }
  return _impl_.dual_solution_;
}
inline ::operations_research::math_opt::DualSolutionProto* PROTOBUF_NONNULL SolutionProto::mutable_dual_solution()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::operations_research::math_opt::DualSolutionProto* _msg = _internal_mutable_dual_solution();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolutionProto.dual_solution)
  return _msg;
}
inline void SolutionProto::set_allocated_dual_solution(::operations_research::math_opt::DualSolutionProto* 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_.dual_solution_);
  }
 
  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_.dual_solution_ = reinterpret_cast<::operations_research::math_opt::DualSolutionProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolutionProto.dual_solution)
}
 
// optional .operations_research.math_opt.BasisProto basis = 3;
inline bool SolutionProto::has_basis() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.basis_ != nullptr);
  return value;
}
inline void SolutionProto::clear_basis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.basis_ != nullptr) _impl_.basis_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000004U);
}
inline const ::operations_research::math_opt::BasisProto& SolutionProto::_internal_basis() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::operations_research::math_opt::BasisProto* p = _impl_.basis_;
  return p != nullptr ? *p : reinterpret_cast<const ::operations_research::math_opt::BasisProto&>(::operations_research::math_opt::_BasisProto_default_instance_);
}
inline const ::operations_research::math_opt::BasisProto& SolutionProto::basis() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:operations_research.math_opt.SolutionProto.basis)
  return _internal_basis();
}
inline void SolutionProto::unsafe_arena_set_allocated_basis(
    ::operations_research::math_opt::BasisProto* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.basis_);
  }
  _impl_.basis_ = reinterpret_cast<::operations_research::math_opt::BasisProto*>(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.SolutionProto.basis)
}
inline ::operations_research::math_opt::BasisProto* PROTOBUF_NULLABLE SolutionProto::release_basis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::BasisProto* released = _impl_.basis_;
  _impl_.basis_ = 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::BasisProto* PROTOBUF_NULLABLE SolutionProto::unsafe_arena_release_basis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:operations_research.math_opt.SolutionProto.basis)
 
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::BasisProto* temp = _impl_.basis_;
  _impl_.basis_ = nullptr;
  return temp;
}
inline ::operations_research::math_opt::BasisProto* PROTOBUF_NONNULL SolutionProto::_internal_mutable_basis() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.basis_ == nullptr) {
    auto* p = ::google::protobuf::Message::DefaultConstruct<::operations_research::math_opt::BasisProto>(GetArena());
    _impl_.basis_ = reinterpret_cast<::operations_research::math_opt::BasisProto*>(p);
  }
  return _impl_.basis_;
}
inline ::operations_research::math_opt::BasisProto* PROTOBUF_NONNULL SolutionProto::mutable_basis()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::operations_research::math_opt::BasisProto* _msg = _internal_mutable_basis();
  // @@protoc_insertion_point(field_mutable:operations_research.math_opt.SolutionProto.basis)
  return _msg;
}
inline void SolutionProto::set_allocated_basis(::operations_research::math_opt::BasisProto* 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_.basis_);
  }
 
  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_.basis_ = reinterpret_cast<::operations_research::math_opt::BasisProto*>(value);
  // @@protoc_insertion_point(field_set_allocated:operations_research.math_opt.SolutionProto.basis)
}
 
#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::SolutionStatusProto> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::math_opt::SolutionStatusProto>() {
  return ::operations_research::math_opt::SolutionStatusProto_descriptor();
}
template <>
struct is_proto_enum<::operations_research::math_opt::BasisStatusProto> : std::true_type {};
template <>
inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::operations_research::math_opt::BasisStatusProto>() {
  return ::operations_research::math_opt::BasisStatusProto_descriptor();
}
 
}  // namespace protobuf
}  // namespace google
 
// @@protoc_insertion_point(global_scope)
 
#include "google/protobuf/port_undef.inc"
 
#endif  // ortools_2fmath_5fopt_2fsolution_2eproto_2epb_2eh